From 806fd17e3f663e42552c3e89e28a4041814c9be5 Mon Sep 17 00:00:00 2001 From: Stefan Forstenlechner <stefanforstenlechner@gmail.com> Date: Fri, 11 Nov 2016 21:19:26 +0000 Subject: [PATCH] add captcha notification - pull request from tonsense (https://github.com/pyload/pyload-android/pull/10) - updated to thrift 0.9.3 - synchronized access to thrift client --- app/src/main/AndroidManifest.xml | 2 + .../apache/thrift/AsyncProcessFunction.java | 56 + .../java/org/apache/thrift/EncodingUtils.java | 63 + .../main/java/org/apache/thrift/Option.java | 121 + .../org/apache/thrift/ProcessFunction.java | 38 +- .../apache/thrift/TApplicationException.java | 3 + .../org/apache/thrift/TAsyncProcessor.java | 35 + .../apache/thrift/TBaseAsyncProcessor.java | 92 + .../java/org/apache/thrift/TBaseHelper.java | 23 +- .../org/apache/thrift/TBaseProcessor.java | 5 + .../apache/thrift/TByteArrayOutputStream.java | 13 +- .../java/org/apache/thrift/TDeserializer.java | 14 +- .../java/org/apache/thrift/TException.java | 2 +- .../apache/thrift/TMultiplexedProcessor.java | 143 + .../thrift/TNonblockingMultiFetchClient.java | 399 + .../thrift/TNonblockingMultiFetchStats.java | 80 + .../org/apache/thrift/TProcessorFactory.java | 4 + .../org/apache/thrift/TServiceClient.java | 14 +- .../main/java/org/apache/thrift/TUnion.java | 11 +- .../thrift/async/TAsyncClientManager.java | 9 +- .../apache/thrift/async/TAsyncMethodCall.java | 8 +- .../thrift/meta_data/FieldMetaData.java | 4 +- .../apache/thrift/protocol/TBase64Utils.java | 11 +- .../thrift/protocol/TBinaryProtocol.java | 103 +- .../thrift/protocol/TCompactProtocol.java | 186 +- .../org/apache/thrift/protocol/TField.java | 20 +- .../apache/thrift/protocol/TJSONProtocol.java | 31 +- .../org/apache/thrift/protocol/TMessage.java | 33 +- .../thrift/protocol/TMultiplexedProtocol.java | 91 + .../thrift/protocol/TProtocolDecorator.java | 213 + .../thrift/protocol/TProtocolException.java | 1 + .../thrift/protocol/TSimpleJSONProtocol.java | 81 +- .../thrift/protocol/TTupleProtocol.java | 2 +- .../server/AbstractNonblockingServer.java | 612 + .../org/apache/thrift/server/Invocation.java | 20 + .../apache/thrift/server/ServerContext.java | 26 + .../org/apache/thrift/server/THsHaServer.java | 179 + .../thrift/server/TNonblockingServer.java | 248 + .../org/apache/thrift/server/TServer.java | 177 + .../thrift/server/TServerEventHandler.java | 59 + .../apache/thrift/server/TSimpleServer.java | 117 + .../thrift/server/TThreadPoolServer.java | 311 + .../server/TThreadedSelectorServer.java | 668 + .../AutoExpandingBufferReadTransport.java | 4 +- .../AutoExpandingBufferWriteTransport.java | 4 +- .../thrift/transport/TFileProcessor.java | 10 - .../thrift/transport/TFileTransport.java | 41 +- .../thrift/transport/TMemoryBuffer.java | 6 +- .../transport/TNonblockingServerSocket.java | 23 +- .../thrift/transport/TNonblockingSocket.java | 1 + .../transport/TSSLTransportFactory.java | 105 +- .../thrift/transport/TServerSocket.java | 32 +- .../thrift/transport/TServerTransport.java | 31 +- .../transport/TSimpleFileTransport.java | 216 + .../org/apache/thrift/transport/TSocket.java | 57 +- .../apache/thrift/transport/TTransport.java | 4 +- .../thrift/transport/TZlibTransport.java | 148 + .../pyload/android/client/Preferences.java | 3 + .../android/client/dialogs/AccountDialog.java | 14 +- .../fragments/AbstractPackageFragment.java | 89 +- .../fragments/ConfigSectionFragment.java | 35 +- .../client/fragments/OverviewFragment.java | 754 +- .../client/fragments/SettingsFragment.java | 12 +- .../org/pyload/android/client/pyLoad.java | 518 +- .../org/pyload/android/client/pyLoadApp.java | 397 +- .../client/service/CheckCaptchaService.java | 107 + .../java/org/pyload/thrift/AccountInfo.java | 2262 +- .../java/org/pyload/thrift/CaptchaTask.java | 1352 +- .../java/org/pyload/thrift/ConfigItem.java | 1336 +- .../java/org/pyload/thrift/ConfigSection.java | 1441 +- .../java/org/pyload/thrift/Destination.java | 61 +- .../java/org/pyload/thrift/DownloadInfo.java | 3710 +- .../org/pyload/thrift/DownloadStatus.java | 139 +- .../java/org/pyload/thrift/ElementType.java | 61 +- .../main/java/org/pyload/thrift/Event.java | 611 - .../java/org/pyload/thrift/EventInfo.java | 1368 +- .../main/java/org/pyload/thrift/FileData.java | 2723 +- .../org/pyload/thrift/FileDoesNotExists.java | 658 +- .../main/java/org/pyload/thrift/Input.java | 66 + .../org/pyload/thrift/InteractionTask.java | 1444 + .../java/org/pyload/thrift/OnlineCheck.java | 1027 +- .../java/org/pyload/thrift/OnlineStatus.java | 1553 +- .../main/java/org/pyload/thrift/Output.java | 45 + .../java/org/pyload/thrift/PackageData.java | 3347 +- .../pyload/thrift/PackageDoesNotExists.java | 658 +- .../main/java/org/pyload/thrift/Pyload.java | 104654 ++++++++------- .../java/org/pyload/thrift/ServerStatus.java | 1867 +- .../java/org/pyload/thrift/ServiceCall.java | 1430 +- .../pyload/thrift/ServiceDoesNotExists.java | 869 +- .../org/pyload/thrift/ServiceException.java | 618 +- .../main/java/org/pyload/thrift/UserData.java | 1525 +- app/src/main/res/menu/menu.xml | 6 + app/src/main/res/values-de/strings.xml | 1 + app/src/main/res/values/strings.xml | 1 + build.gradle | 2 +- gradle/wrapper/gradle-wrapper.properties | 4 +- 96 files changed, 78711 insertions(+), 63067 deletions(-) create mode 100644 app/src/main/java/org/apache/thrift/AsyncProcessFunction.java create mode 100644 app/src/main/java/org/apache/thrift/Option.java create mode 100644 app/src/main/java/org/apache/thrift/TAsyncProcessor.java create mode 100644 app/src/main/java/org/apache/thrift/TBaseAsyncProcessor.java create mode 100644 app/src/main/java/org/apache/thrift/TMultiplexedProcessor.java create mode 100644 app/src/main/java/org/apache/thrift/TNonblockingMultiFetchClient.java create mode 100644 app/src/main/java/org/apache/thrift/TNonblockingMultiFetchStats.java create mode 100644 app/src/main/java/org/apache/thrift/protocol/TMultiplexedProtocol.java create mode 100644 app/src/main/java/org/apache/thrift/protocol/TProtocolDecorator.java create mode 100644 app/src/main/java/org/apache/thrift/server/AbstractNonblockingServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/Invocation.java create mode 100644 app/src/main/java/org/apache/thrift/server/ServerContext.java create mode 100644 app/src/main/java/org/apache/thrift/server/THsHaServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/TNonblockingServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/TServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/TServerEventHandler.java create mode 100644 app/src/main/java/org/apache/thrift/server/TSimpleServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/TThreadPoolServer.java create mode 100644 app/src/main/java/org/apache/thrift/server/TThreadedSelectorServer.java create mode 100644 app/src/main/java/org/apache/thrift/transport/TSimpleFileTransport.java create mode 100644 app/src/main/java/org/apache/thrift/transport/TZlibTransport.java create mode 100644 app/src/main/java/org/pyload/android/client/service/CheckCaptchaService.java delete mode 100644 app/src/main/java/org/pyload/thrift/Event.java create mode 100644 app/src/main/java/org/pyload/thrift/Input.java create mode 100644 app/src/main/java/org/pyload/thrift/InteractionTask.java create mode 100644 app/src/main/java/org/pyload/thrift/Output.java diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index bdff19d..27cd518 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -97,5 +97,7 @@ <activity android:name=".RemoteSettings" android:label="@string/remotesettings_activity"/> + <service android:name=".service.CheckCaptchaService" /> + </application> </manifest> diff --git a/app/src/main/java/org/apache/thrift/AsyncProcessFunction.java b/app/src/main/java/org/apache/thrift/AsyncProcessFunction.java new file mode 100644 index 0000000..799e02d --- /dev/null +++ b/app/src/main/java/org/apache/thrift/AsyncProcessFunction.java @@ -0,0 +1,56 @@ +/* + * 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.thrift; + +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.protocol.TMessage; +import org.apache.thrift.protocol.TMessageType; +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.server.AbstractNonblockingServer; + +public abstract class AsyncProcessFunction<I, T, R> { + final String methodName; + + public AsyncProcessFunction(String methodName) { + this.methodName = methodName; + } + + protected abstract boolean isOneway(); + + public abstract void start(I iface, T args, AsyncMethodCallback<R> resultHandler) throws TException; + + public abstract T getEmptyArgsInstance(); + + public abstract AsyncMethodCallback getResultHandler(final AbstractNonblockingServer.AsyncFrameBuffer fb, int seqid); + + public String getMethodName() { + return methodName; + } + + public void sendResponse(final AbstractNonblockingServer.AsyncFrameBuffer fb, final TBase result, final byte type, final int seqid) throws TException { + TProtocol oprot = fb.getOutputProtocol(); + + oprot.writeMessageBegin(new TMessage(getMethodName(), type, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + + fb.responseReady(); + } +} diff --git a/app/src/main/java/org/apache/thrift/EncodingUtils.java b/app/src/main/java/org/apache/thrift/EncodingUtils.java index 072de93..bf14ef5 100644 --- a/app/src/main/java/org/apache/thrift/EncodingUtils.java +++ b/app/src/main/java/org/apache/thrift/EncodingUtils.java @@ -82,4 +82,67 @@ public static final int decodeBigEndian(final byte[] buf, int offset) { | ((buf[offset + 2] & 0xff) << 8) | ((buf[offset + 3] & 0xff)); } + /** + * Bitfield utilities. + * Returns true if the bit at position is set in v. + */ + public static final boolean testBit(byte v, int position) { + return testBit((int)v, position); + } + + public static final boolean testBit(short v, int position) { + return testBit((int)v, position); + } + + public static final boolean testBit(int v, int position) { + return (v & (1 << position)) != 0; + } + + public static final boolean testBit(long v, int position) { + return (v & (1L << position)) != 0L; + } + + /** + * Returns v, with the bit at position set to zero. + */ + public static final byte clearBit(byte v, int position) { + return (byte)clearBit((int)v, position); + } + + public static final short clearBit(short v, int position) { + return (short)clearBit((int)v, position); + } + + public static final int clearBit(int v, int position) { + return v & ~(1 << position); + } + + public static final long clearBit(long v, int position) { + return v & ~(1L << position); + } + + /** + * Returns v, with the bit at position set to 1 or 0 depending on value. + */ + public static final byte setBit(byte v, int position, boolean value) { + return (byte)setBit((int)v, position, value); + } + + public static final short setBit(short v, int position, boolean value) { + return (short)setBit((int)v, position, value); + } + + public static final int setBit(int v, int position, boolean value) { + if(value) + return v | (1 << position); + else + return clearBit(v, position); + } + + public static final long setBit(long v, int position, boolean value) { + if(value) + return v | (1L << position); + else + return clearBit(v, position); + } } diff --git a/app/src/main/java/org/apache/thrift/Option.java b/app/src/main/java/org/apache/thrift/Option.java new file mode 100644 index 0000000..db25ec5 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/Option.java @@ -0,0 +1,121 @@ +/* + * 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.thrift; + +/** + * Implementation of the Option type pattern + */ +public abstract class Option<T> { + + /** + * Whether the Option is defined or not + * @return + * true if the Option is defined (of type Some) + * false if the Option is not defined (of type None) + */ + public abstract boolean isDefined(); + + /** + * Get the value of the Option (if it is defined) + * @return the value + * @throws IllegalStateException if called on a None + */ + public abstract T get(); + + /** + * Get the contained value (if defined) or else return a default value + * @param other what to return if the value is not defined (a None) + * @return either the value, or other if the value is not defined + */ + public T or(T other) { + if (isDefined()) { + return get(); + } else { + return other; + } + } + /** + * The None type, representing an absent value (instead of "null") + */ + public static class None<T> extends Option<T> { + public boolean isDefined() { + return false; + } + + public T get() { + throw new IllegalStateException("Cannot call get() on None"); + } + + public String toString() { + return "None"; + } + } + + /** + * The Some type, representing an existence of some value + * @param <T> The type of value + */ + public static class Some<T> extends Option<T> { + private final T value; + public Some(T value) { + this.value = value; + } + + public boolean isDefined() { + return true; + } + + public T get() { + return value; + } + + public String toString() { + return "Some("+value.toString()+")"; + } + } + + /** + * Wraps value in an Option type, depending on whether or not value is null + * @param value + * @param <T> type of value + * @return Some(value) if value is not null, None if value is null + */ + public static <T> Option<T> fromNullable(T value) { + if (value != null) { + return new Some<T>(value); + } else { + return new None<T>(); + } + } + + /** + * Wrap value in a Some type (NB! value must not be null!) + * @param value + * @param <T> type of value + * @return a new Some(value) + */ + public static <T> Some<T> some(T value) { + return new Some<T>(value); + } + + public static <T> None<T> none() { + return new None<T>(); + } +} \ No newline at end of file diff --git a/app/src/main/java/org/apache/thrift/ProcessFunction.java b/app/src/main/java/org/apache/thrift/ProcessFunction.java index e0cdc7b..19c8f14 100644 --- a/app/src/main/java/org/apache/thrift/ProcessFunction.java +++ b/app/src/main/java/org/apache/thrift/ProcessFunction.java @@ -7,10 +7,14 @@ import org.apache.thrift.protocol.TMessageType; import org.apache.thrift.protocol.TProtocol; import org.apache.thrift.protocol.TProtocolException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; public abstract class ProcessFunction<I, T extends TBase> { private final String methodName; + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessFunction.class.getName()); + public ProcessFunction(String methodName) { this.methodName = methodName; } @@ -29,18 +33,36 @@ public final void process(int seqid, TProtocol iprot, TProtocol oprot, I iface) return; } iprot.readMessageEnd(); - TBase result = getResult(iface, args); - oprot.writeMessageBegin(new TMessage(getMethodName(), TMessageType.REPLY, seqid)); - result.write(oprot); - oprot.writeMessageEnd(); - oprot.getTransport().flush(); + TBase result = null; + + try { + result = getResult(iface, args); + } catch(TException tex) { + LOGGER.error("Internal error processing " + getMethodName(), tex); + TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, + "Internal error processing " + getMethodName()); + oprot.writeMessageBegin(new TMessage(getMethodName(), TMessageType.EXCEPTION, seqid)); + x.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + return; + } + + if(!isOneway()) { + oprot.writeMessageBegin(new TMessage(getMethodName(), TMessageType.REPLY, seqid)); + result.write(oprot); + oprot.writeMessageEnd(); + oprot.getTransport().flush(); + } } - protected abstract TBase getResult(I iface, T args) throws TException; + protected abstract boolean isOneway(); + + public abstract TBase getResult(I iface, T args) throws TException; - protected abstract T getEmptyArgsInstance(); + public abstract T getEmptyArgsInstance(); public String getMethodName() { return methodName; } -} \ No newline at end of file +} diff --git a/app/src/main/java/org/apache/thrift/TApplicationException.java b/app/src/main/java/org/apache/thrift/TApplicationException.java index c294fc3..b54a5ce 100644 --- a/app/src/main/java/org/apache/thrift/TApplicationException.java +++ b/app/src/main/java/org/apache/thrift/TApplicationException.java @@ -45,6 +45,9 @@ public class TApplicationException extends TException { public static final int MISSING_RESULT = 5; public static final int INTERNAL_ERROR = 6; public static final int PROTOCOL_ERROR = 7; + public static final int INVALID_TRANSFORM = 8; + public static final int INVALID_PROTOCOL = 9; + public static final int UNSUPPORTED_CLIENT_TYPE = 10; protected int type_ = UNKNOWN; diff --git a/app/src/main/java/org/apache/thrift/TAsyncProcessor.java b/app/src/main/java/org/apache/thrift/TAsyncProcessor.java new file mode 100644 index 0000000..0a069ea --- /dev/null +++ b/app/src/main/java/org/apache/thrift/TAsyncProcessor.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.thrift; + +import org.apache.thrift.protocol.*; + +import org.apache.thrift.server.AbstractNonblockingServer.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Collections; +import java.util.Map; + +public interface TAsyncProcessor { + /** + * Implementations must call fb.responseReady() once processing is complete + */ + public boolean process(final AsyncFrameBuffer fb) throws TException; +} diff --git a/app/src/main/java/org/apache/thrift/TBaseAsyncProcessor.java b/app/src/main/java/org/apache/thrift/TBaseAsyncProcessor.java new file mode 100644 index 0000000..ed6c323 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/TBaseAsyncProcessor.java @@ -0,0 +1,92 @@ +/* + * 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.thrift; + +import org.apache.thrift.protocol.*; + +import org.apache.thrift.server.AbstractNonblockingServer.*; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Collections; +import java.util.Map; + +public class TBaseAsyncProcessor<I> implements TAsyncProcessor, TProcessor { + protected final Logger LOGGER = LoggerFactory.getLogger(getClass().getName()); + + final I iface; + final Map<String,AsyncProcessFunction<I, ? extends TBase,?>> processMap; + + public TBaseAsyncProcessor(I iface, Map<String, AsyncProcessFunction<I, ? extends TBase,?>> processMap) { + this.iface = iface; + this.processMap = processMap; + } + + public Map<String,AsyncProcessFunction<I, ? extends TBase,?>> getProcessMapView() { + return Collections.unmodifiableMap(processMap); + } + + public boolean process(final AsyncFrameBuffer fb) throws TException { + + final TProtocol in = fb.getInputProtocol(); + final TProtocol out = fb.getOutputProtocol(); + + //Find processing function + final TMessage msg = in.readMessageBegin(); + AsyncProcessFunction fn = processMap.get(msg.name); + if (fn == null) { + TProtocolUtil.skip(in, TType.STRUCT); + in.readMessageEnd(); + TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'"); + out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); + x.write(out); + out.writeMessageEnd(); + out.getTransport().flush(); + fb.responseReady(); + return true; + } + + //Get Args + TBase args = (TBase)fn.getEmptyArgsInstance(); + + try { + args.read(in); + } catch (TProtocolException e) { + in.readMessageEnd(); + TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage()); + out.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid)); + x.write(out); + out.writeMessageEnd(); + out.getTransport().flush(); + fb.responseReady(); + return true; + } + in.readMessageEnd(); + + + //start off processing function + fn.start(iface, args,fn.getResultHandler(fb,msg.seqid)); + return true; + } + + @Override + public boolean process(TProtocol in, TProtocol out) throws TException { + return false; + } +} diff --git a/app/src/main/java/org/apache/thrift/TBaseHelper.java b/app/src/main/java/org/apache/thrift/TBaseHelper.java index eec648b..5517536 100644 --- a/app/src/main/java/org/apache/thrift/TBaseHelper.java +++ b/app/src/main/java/org/apache/thrift/TBaseHelper.java @@ -17,6 +17,7 @@ */ package org.apache.thrift; +import java.io.Serializable; import java.nio.ByteBuffer; import java.util.Comparator; import java.util.Iterator; @@ -27,6 +28,7 @@ import java.util.SortedSet; import java.util.TreeMap; import java.util.TreeSet; +import java.util.Collection; public final class TBaseHelper { @@ -198,7 +200,7 @@ public static int compareTo(Map a, Map b) { /** * Comparator to compare items inside a structure (e.g. a list, set, or map). */ - private static class NestedStructureComparator implements Comparator { + private static class NestedStructureComparator implements Comparator, Serializable { public int compare(Object oA, Object oB) { if (oA == null && oB == null) { return 0; @@ -220,6 +222,25 @@ public int compare(Object oA, Object oB) { } } + public static void toString(Collection<ByteBuffer> bbs, StringBuilder sb) { + Iterator<ByteBuffer> it = bbs.iterator(); + if (!it.hasNext()) { + sb.append("[]"); + } else { + sb.append("["); + while (true) { + ByteBuffer bb = it.next(); + org.apache.thrift.TBaseHelper.toString(bb, sb); + if (!it.hasNext()) { + sb.append("]"); + return; + } else { + sb.append(", "); + } + } + } + } + public static void toString(ByteBuffer bb, StringBuilder sb) { byte[] buf = bb.array(); diff --git a/app/src/main/java/org/apache/thrift/TBaseProcessor.java b/app/src/main/java/org/apache/thrift/TBaseProcessor.java index f93b133..f9a9a9e 100644 --- a/app/src/main/java/org/apache/thrift/TBaseProcessor.java +++ b/app/src/main/java/org/apache/thrift/TBaseProcessor.java @@ -1,5 +1,6 @@ package org.apache.thrift; +import java.util.Collections; import java.util.Map; import org.apache.thrift.protocol.TMessage; @@ -17,6 +18,10 @@ protected TBaseProcessor(I iface, Map<String, ProcessFunction<I, ? extends TBase this.processMap = processFunctionMap; } + public Map<String,ProcessFunction<I, ? extends TBase>> getProcessMapView() { + return Collections.unmodifiableMap(processMap); + } + @Override public boolean process(TProtocol in, TProtocol out) throws TException { TMessage msg = in.readMessageBegin(); diff --git a/app/src/main/java/org/apache/thrift/TByteArrayOutputStream.java b/app/src/main/java/org/apache/thrift/TByteArrayOutputStream.java index 9ed83c0..1c37ecd 100644 --- a/app/src/main/java/org/apache/thrift/TByteArrayOutputStream.java +++ b/app/src/main/java/org/apache/thrift/TByteArrayOutputStream.java @@ -27,18 +27,29 @@ * */ public class TByteArrayOutputStream extends ByteArrayOutputStream { + + private final int initialSize; + public TByteArrayOutputStream(int size) { super(size); + this.initialSize = size; } public TByteArrayOutputStream() { - super(); + this(32); } public byte[] get() { return buf; } + public void reset() { + super.reset(); + if (buf.length > initialSize) { + buf = new byte[initialSize]; + } + } + public int len() { return count; } diff --git a/app/src/main/java/org/apache/thrift/TDeserializer.java b/app/src/main/java/org/apache/thrift/TDeserializer.java index 803d9c6..bf6c97c 100644 --- a/app/src/main/java/org/apache/thrift/TDeserializer.java +++ b/app/src/main/java/org/apache/thrift/TDeserializer.java @@ -64,8 +64,20 @@ public TDeserializer(TProtocolFactory protocolFactory) { * @param bytes The array to read from */ public void deserialize(TBase base, byte[] bytes) throws TException { + deserialize(base, bytes, 0, bytes.length); + } + + /** + * Deserialize the Thrift object from a byte array. + * + * @param base The object to read into + * @param bytes The array to read from + * @param offset The offset into {@code bytes} + * @param length The length to read from {@code bytes} + */ + public void deserialize(TBase base, byte[] bytes, int offset, int length) throws TException { try { - trans_.reset(bytes); + trans_.reset(bytes, offset, length); base.read(protocol_); } finally { trans_.clear(); diff --git a/app/src/main/java/org/apache/thrift/TException.java b/app/src/main/java/org/apache/thrift/TException.java index cc3160f..f84f481 100644 --- a/app/src/main/java/org/apache/thrift/TException.java +++ b/app/src/main/java/org/apache/thrift/TException.java @@ -23,7 +23,7 @@ * Generic exception class for Thrift. * */ -public class TException extends RuntimeException { +public class TException extends Exception { private static final long serialVersionUID = 1L; diff --git a/app/src/main/java/org/apache/thrift/TMultiplexedProcessor.java b/app/src/main/java/org/apache/thrift/TMultiplexedProcessor.java new file mode 100644 index 0000000..f6547ac --- /dev/null +++ b/app/src/main/java/org/apache/thrift/TMultiplexedProcessor.java @@ -0,0 +1,143 @@ +/* + * 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.thrift; + +import org.apache.thrift.protocol.*; + +import java.util.Map; +import java.util.HashMap; + +/** + * <code>TMultiplexedProcessor</code> is a <code>TProcessor</code> allowing + * a single <code>TServer</code> to provide multiple services. + * + * <p>To do so, you instantiate the processor and then register additional + * processors with it, as shown in the following example:</p> + * + * <blockquote><code> + * TMultiplexedProcessor processor = new TMultiplexedProcessor(); + * + * processor.registerProcessor( + * "Calculator", + * new Calculator.Processor(new CalculatorHandler())); + * + * processor.registerProcessor( + * "WeatherReport", + * new WeatherReport.Processor(new WeatherReportHandler())); + * + * TServerTransport t = new TServerSocket(9090); + * TSimpleServer server = new TSimpleServer(processor, t); + * + * server.serve(); + * </code></blockquote> + */ +public class TMultiplexedProcessor implements TProcessor { + + private final Map<String,TProcessor> SERVICE_PROCESSOR_MAP + = new HashMap<String,TProcessor>(); + + /** + * 'Register' a service with this <code>TMultiplexedProcessor</code>. This + * allows us to broker requests to individual services by using the service + * name to select them at request time. + * + * @param serviceName Name of a service, has to be identical to the name + * declared in the Thrift IDL, e.g. "WeatherReport". + * @param processor Implementation of a service, usually referred to + * as "handlers", e.g. WeatherReportHandler implementing WeatherReport.Iface. + */ + public void registerProcessor(String serviceName, TProcessor processor) { + SERVICE_PROCESSOR_MAP.put(serviceName, processor); + } + + /** + * This implementation of <code>process</code> performs the following steps: + * + * <ol> + * <li>Read the beginning of the message.</li> + * <li>Extract the service name from the message.</li> + * <li>Using the service name to locate the appropriate processor.</li> + * <li>Dispatch to the processor, with a decorated instance of TProtocol + * that allows readMessageBegin() to return the original TMessage.</li> + * </ol> + * + * @throws TException If the message type is not CALL or ONEWAY, if + * the service name was not found in the message, or if the service + * name was not found in the service map. You called {@link #registerProcessor(String, TProcessor) registerProcessor} + * during initialization, right? :) + */ + public boolean process(TProtocol iprot, TProtocol oprot) throws TException { + /* + Use the actual underlying protocol (e.g. TBinaryProtocol) to read the + message header. This pulls the message "off the wire", which we'll + deal with at the end of this method. + */ + TMessage message = iprot.readMessageBegin(); + + if (message.type != TMessageType.CALL && message.type != TMessageType.ONEWAY) { + // TODO Apache Guys - Can the server ever get an EXCEPTION or REPLY? + // TODO Should we check for this here? + throw new TException("This should not have happened!?"); + } + + // Extract the service name + int index = message.name.indexOf(TMultiplexedProtocol.SEPARATOR); + if (index < 0) { + throw new TException("Service name not found in message name: " + message.name + ". Did you " + + "forget to use a TMultiplexProtocol in your client?"); + } + + // Create a new TMessage, something that can be consumed by any TProtocol + String serviceName = message.name.substring(0, index); + TProcessor actualProcessor = SERVICE_PROCESSOR_MAP.get(serviceName); + if (actualProcessor == null) { + throw new TException("Service name not found: " + serviceName + ". Did you forget " + + "to call registerProcessor()?"); + } + + // Create a new TMessage, removing the service name + TMessage standardMessage = new TMessage( + message.name.substring(serviceName.length()+TMultiplexedProtocol.SEPARATOR.length()), + message.type, + message.seqid + ); + + // Dispatch processing to the stored processor + return actualProcessor.process(new StoredMessageProtocol(iprot, standardMessage), oprot); + } + + /** + * Our goal was to work with any protocol. In order to do that, we needed + * to allow them to call readMessageBegin() and get a TMessage in exactly + * the standard format, without the service name prepended to TMessage.name. + */ + private static class StoredMessageProtocol extends TProtocolDecorator { + TMessage messageBegin; + public StoredMessageProtocol(TProtocol protocol, TMessage messageBegin) { + super(protocol); + this.messageBegin = messageBegin; + } + @Override + public TMessage readMessageBegin() throws TException { + return messageBegin; + } + } + +} diff --git a/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchClient.java b/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchClient.java new file mode 100644 index 0000000..382d978 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchClient.java @@ -0,0 +1,399 @@ +/** + * 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.thrift; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.net.InetSocketAddress; +import java.nio.ByteBuffer; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.SocketChannel; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.FutureTask; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + + +/** + * This class uses a single thread to set up non-blocking sockets to a set + * of remote servers (hostname and port pairs), and sends a same request to + * all these servers. It then fetches responses from servers. + * + * Parameters: + * int maxRecvBufBytesPerServer - an upper limit for receive buffer size + * per server (in byte). If a response from a server exceeds this limit, the + * client will not allocate memory or read response data for it. + * + * int fetchTimeoutSeconds - time limit for fetching responses from all + * servers (in second). After the timeout, the fetch job is stopped and + * available responses are returned. + * + * ByteBuffer requestBuf - request message that is sent to all servers. + * + * Output: + * Responses are stored in an array of ByteBuffers. Index of elements in + * this array corresponds to index of servers in the server list. Content in + * a ByteBuffer may be in one of the following forms: + * 1. First 4 bytes form an integer indicating length of following data, + * then followed by the data. + * 2. First 4 bytes form an integer indicating length of following data, + * then followed by nothing - this happens when the response data size + * exceeds maxRecvBufBytesPerServer, and the client will not read any + * response data. + * 3. No data in the ByteBuffer - this happens when the server does not + * return any response within fetchTimeoutSeconds. + * + * In some special cases (no servers are given, fetchTimeoutSeconds less + * than or equal to 0, requestBuf is null), the return is null. + * + * Note: + * It assumes all remote servers are TNonblockingServers and use + * TFramedTransport. + * + */ +public class TNonblockingMultiFetchClient { + + private static final Logger LOGGER = LoggerFactory.getLogger( + TNonblockingMultiFetchClient.class.getName() + ); + + // if the size of the response msg exceeds this limit (in byte), we will + // not read the msg + private int maxRecvBufBytesPerServer; + + // time limit for fetching data from all servers (in second) + private int fetchTimeoutSeconds; + + // store request that will be sent to servers + private ByteBuffer requestBuf; + private ByteBuffer requestBufDuplication; + + // a list of remote servers + private List<InetSocketAddress> servers; + + // store fetch results + private TNonblockingMultiFetchStats stats; + private ByteBuffer[] recvBuf; + + public TNonblockingMultiFetchClient(int maxRecvBufBytesPerServer, + int fetchTimeoutSeconds, ByteBuffer requestBuf, + List<InetSocketAddress> servers) { + this.maxRecvBufBytesPerServer = maxRecvBufBytesPerServer; + this.fetchTimeoutSeconds = fetchTimeoutSeconds; + this.requestBuf = requestBuf; + this.servers = servers; + + stats = new TNonblockingMultiFetchStats(); + recvBuf = null; + } + + public synchronized int getMaxRecvBufBytesPerServer() { + return maxRecvBufBytesPerServer; + } + + public synchronized int getFetchTimeoutSeconds() { + return fetchTimeoutSeconds; + } + + /** + * return a duplication of requestBuf, so that requestBuf will not + * be modified by others. + */ + public synchronized ByteBuffer getRequestBuf() { + if (requestBuf == null) { + return null; + } else { + if (requestBufDuplication == null) { + requestBufDuplication = requestBuf.duplicate(); + } + return requestBufDuplication; + } + } + + public synchronized List<InetSocketAddress> getServerList() { + if (servers == null) { + return null; + } + return Collections.unmodifiableList(servers); + } + + public synchronized TNonblockingMultiFetchStats getFetchStats() { + return stats; + } + + /** + * main entry function for fetching from servers + */ + public synchronized ByteBuffer[] fetch() { + // clear previous results + recvBuf = null; + stats.clear(); + + if (servers == null || servers.size() == 0 || + requestBuf == null || fetchTimeoutSeconds <= 0) { + return recvBuf; + } + + ExecutorService executor = Executors.newSingleThreadExecutor(); + MultiFetch multiFetch = new MultiFetch(); + FutureTask<?> task = new FutureTask(multiFetch, null); + executor.execute(task); + try { + task.get(fetchTimeoutSeconds, TimeUnit.SECONDS); + } catch(InterruptedException ie) { + // attempt to cancel execution of the task. + task.cancel(true); + LOGGER.error("interrupted during fetch: "+ie.toString()); + } catch(ExecutionException ee) { + // attempt to cancel execution of the task. + task.cancel(true); + LOGGER.error("exception during fetch: "+ee.toString()); + } catch(TimeoutException te) { + // attempt to cancel execution of the task. + task.cancel(true); + LOGGER.error("timeout for fetch: "+te.toString()); + } + + executor.shutdownNow(); + multiFetch.close(); + return recvBuf; + } + + /** + * Private class that does real fetch job. + * Users are not allowed to directly use this class, as its run() + * function may run forever. + */ + private class MultiFetch implements Runnable { + private Selector selector; + + /** + * main entry function for fetching. + * + * Server responses are stored in TNonblocingMultiFetchClient.recvBuf, + * and fetch statistics is in TNonblockingMultiFetchClient.stats. + * + * Sanity check for parameters has been done in + * TNonblockingMultiFetchClient before calling this function. + */ + public void run() { + long t1 = System.currentTimeMillis(); + + int numTotalServers = servers.size(); + stats.setNumTotalServers(numTotalServers); + + // buffer for receiving response from servers + recvBuf = new ByteBuffer[numTotalServers]; + // buffer for sending request + ByteBuffer sendBuf[] = new ByteBuffer[numTotalServers]; + long numBytesRead[] = new long[numTotalServers]; + int frameSize[] = new int[numTotalServers]; + boolean hasReadFrameSize[] = new boolean[numTotalServers]; + + try { + selector = Selector.open(); + } catch (IOException e) { + LOGGER.error("selector opens error: "+e.toString()); + return; + } + + for (int i = 0; i < numTotalServers; i++) { + // create buffer to send request to server. + sendBuf[i] = requestBuf.duplicate(); + // create buffer to read response's frame size from server + recvBuf[i] = ByteBuffer.allocate(4); + stats.incTotalRecvBufBytes(4); + + InetSocketAddress server = servers.get(i); + SocketChannel s = null; + SelectionKey key = null; + try { + s = SocketChannel.open(); + s.configureBlocking(false); + // now this method is non-blocking + s.connect(server); + key = s.register(selector, s.validOps()); + // attach index of the key + key.attach(i); + } catch (Exception e) { + stats.incNumConnectErrorServers(); + String err = String.format("set up socket to server %s error: %s", + server.toString(), e.toString()); + LOGGER.error(err); + // free resource + if (s != null) { + try {s.close();} catch (Exception ex) {} + } + if (key != null) { + key.cancel(); + } + } + } + + // wait for events + while (stats.getNumReadCompletedServers() + + stats.getNumConnectErrorServers() < stats.getNumTotalServers()) { + // if the thread is interrupted (e.g., task is cancelled) + if (Thread.currentThread().isInterrupted()) { + return; + } + + try{ + selector.select(); + } catch (Exception e) { + LOGGER.error("selector selects error: "+e.toString()); + continue; + } + + Iterator<SelectionKey> it = selector.selectedKeys().iterator(); + while (it.hasNext()) { + SelectionKey selKey = it.next(); + it.remove(); + + // get previously attached index + int index = (Integer)selKey.attachment(); + + if (selKey.isValid() && selKey.isConnectable()) { + // if this socket throws an exception (e.g., connection refused), + // print error msg and skip it. + try { + SocketChannel sChannel = (SocketChannel)selKey.channel(); + sChannel.finishConnect(); + } catch (Exception e) { + stats.incNumConnectErrorServers(); + String err = String.format("socket %d connects to server %s " + + "error: %s", + index, servers.get(index).toString(), e.toString()); + LOGGER.error(err); + } + } + + if (selKey.isValid() && selKey.isWritable()) { + if (sendBuf[index].hasRemaining()) { + // if this socket throws an exception, print error msg and + // skip it. + try { + SocketChannel sChannel = (SocketChannel)selKey.channel(); + sChannel.write(sendBuf[index]); + } catch (Exception e) { + String err = String.format("socket %d writes to server %s " + + "error: %s", + index, servers.get(index).toString(), e.toString()); + LOGGER.error(err); + } + } + } + + if (selKey.isValid() && selKey.isReadable()) { + // if this socket throws an exception, print error msg and + // skip it. + try { + SocketChannel sChannel = (SocketChannel)selKey.channel(); + int bytesRead = sChannel.read(recvBuf[index]); + + if (bytesRead > 0) { + numBytesRead[index] += bytesRead; + + if (!hasReadFrameSize[index] && + recvBuf[index].remaining()==0) { + // if the frame size has been read completely, then prepare + // to read the actual frame. + frameSize[index] = recvBuf[index].getInt(0); + + if (frameSize[index] <= 0) { + stats.incNumInvalidFrameSize(); + String err = String.format("Read an invalid frame size %d" + + " from %s. Does the server use TFramedTransport? ", + frameSize[index], servers.get(index).toString()); + LOGGER.error(err); + sChannel.close(); + continue; + } + + if (frameSize[index] + 4 > stats.getMaxResponseBytes()) { + stats.setMaxResponseBytes(frameSize[index]+4); + } + + if (frameSize[index] + 4 > maxRecvBufBytesPerServer) { + stats.incNumOverflowedRecvBuf(); + String err = String.format("Read frame size %d from %s," + + " total buffer size would exceed limit %d", + frameSize[index], servers.get(index).toString(), + maxRecvBufBytesPerServer); + LOGGER.error(err); + sChannel.close(); + continue; + } + + // reallocate buffer for actual frame data + recvBuf[index] = ByteBuffer.allocate(frameSize[index] + 4); + recvBuf[index].putInt(frameSize[index]); + + stats.incTotalRecvBufBytes(frameSize[index]); + hasReadFrameSize[index] = true; + } + + if (hasReadFrameSize[index] && + numBytesRead[index] >= frameSize[index]+4) { + // has read all data + sChannel.close(); + stats.incNumReadCompletedServers(); + long t2 = System.currentTimeMillis(); + stats.setReadTime(t2-t1); + } + } + } catch (Exception e) { + String err = String.format("socket %d reads from server %s " + + "error: %s", + index, servers.get(index).toString(), e.toString()); + LOGGER.error(err); + } + } + } + } + } + + /** + * dispose any resource allocated + */ + public void close() { + try { + if (selector.isOpen()) { + Iterator<SelectionKey> it = selector.keys().iterator(); + while (it.hasNext()) { + SelectionKey selKey = it.next(); + SocketChannel sChannel = (SocketChannel)selKey.channel(); + sChannel.close(); + } + + selector.close(); + } + } catch (IOException e) { + LOGGER.error("free resource error: "+e.toString()); + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchStats.java b/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchStats.java new file mode 100644 index 0000000..90b8620 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/TNonblockingMultiFetchStats.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.thrift; + +/** + * This class keeps track of statistics for TNonblockinMultiFetchClient. + */ +public class TNonblockingMultiFetchStats { + private int numTotalServers; + private int numReadCompletedServers; + private int numConnectErrorServers; + private int totalRecvBufBytes; + private int maxResponseBytes; + private int numOverflowedRecvBuf; + private int numInvalidFrameSize; + // time from the beginning of fetch() function to the reading finish + // time of the last socket (in milli-second) + private long readTime; + + public TNonblockingMultiFetchStats() { + clear(); + } + + public void clear() { + numTotalServers = 0; + numReadCompletedServers = 0; + numConnectErrorServers = 0; + totalRecvBufBytes = 0; + maxResponseBytes = 0; + numOverflowedRecvBuf = 0; + numInvalidFrameSize = 0; + readTime = 0; + } + + public String toString() { + String stats = String.format("numTotalServers=%d, " + + "numReadCompletedServers=%d, numConnectErrorServers=%d, " + + "numUnresponsiveServers=%d, totalRecvBufBytes=%fM, " + + "maxResponseBytes=%d, numOverflowedRecvBuf=%d, " + + "numInvalidFrameSize=%d, readTime=%dms", + numTotalServers, numReadCompletedServers, numConnectErrorServers, + (numTotalServers-numReadCompletedServers-numConnectErrorServers), + totalRecvBufBytes/1024.0/1024, maxResponseBytes, numOverflowedRecvBuf, + numInvalidFrameSize, readTime); + return stats; + } + + public void setNumTotalServers(int val) { numTotalServers = val; } + public void setMaxResponseBytes(int val) { maxResponseBytes = val; } + public void setReadTime(long val) { readTime = val; } + public void incNumReadCompletedServers() { numReadCompletedServers++; } + public void incNumConnectErrorServers() { numConnectErrorServers++; } + public void incNumOverflowedRecvBuf() { numOverflowedRecvBuf++; } + public void incTotalRecvBufBytes(int val) { totalRecvBufBytes += val; } + public void incNumInvalidFrameSize() { numInvalidFrameSize++; } + + public int getMaxResponseBytes() { return maxResponseBytes; } + public int getNumReadCompletedServers() { return numReadCompletedServers; } + public int getNumConnectErrorServers() { return numConnectErrorServers; } + public int getNumTotalServers() { return numTotalServers; } + public int getNumOverflowedRecvBuf() { return numOverflowedRecvBuf;} + public int getTotalRecvBufBytes() { return totalRecvBufBytes;} + public int getNumInvalidFrameSize() { return numInvalidFrameSize; } + public long getReadTime() { return readTime; } +} diff --git a/app/src/main/java/org/apache/thrift/TProcessorFactory.java b/app/src/main/java/org/apache/thrift/TProcessorFactory.java index bcd8a38..81933a2 100644 --- a/app/src/main/java/org/apache/thrift/TProcessorFactory.java +++ b/app/src/main/java/org/apache/thrift/TProcessorFactory.java @@ -36,4 +36,8 @@ public TProcessorFactory(TProcessor processor) { public TProcessor getProcessor(TTransport trans) { return processor_; } + + public boolean isAsyncProcessor() { + return processor_ instanceof TAsyncProcessor; + } } diff --git a/app/src/main/java/org/apache/thrift/TServiceClient.java b/app/src/main/java/org/apache/thrift/TServiceClient.java index 15715f1..259a507 100644 --- a/app/src/main/java/org/apache/thrift/TServiceClient.java +++ b/app/src/main/java/org/apache/thrift/TServiceClient.java @@ -58,14 +58,22 @@ public TProtocol getOutputProtocol() { return this.oprot_; } - protected void sendBase(String methodName, TBase args) throws TException { - oprot_.writeMessageBegin(new TMessage(methodName, TMessageType.CALL, ++seqid_)); + protected void sendBase(String methodName, TBase<?,?> args) throws TException { + sendBase(methodName, args, TMessageType.CALL); + } + + protected void sendBaseOneway(String methodName, TBase<?,?> args) throws TException { + sendBase(methodName, args, TMessageType.ONEWAY); + } + + private void sendBase(String methodName, TBase<?,?> args, byte type) throws TException { + oprot_.writeMessageBegin(new TMessage(methodName, type, ++seqid_)); args.write(oprot_); oprot_.writeMessageEnd(); oprot_.getTransport().flush(); } - protected void receiveBase(TBase result, String methodName) throws TException { + protected void receiveBase(TBase<?,?> result, String methodName) throws TException { TMessage msg = iprot_.readMessageBegin(); if (msg.type == TMessageType.EXCEPTION) { TApplicationException x = TApplicationException.read(iprot_); diff --git a/app/src/main/java/org/apache/thrift/TUnion.java b/app/src/main/java/org/apache/thrift/TUnion.java index 0173f9b..3052ee1 100644 --- a/app/src/main/java/org/apache/thrift/TUnion.java +++ b/app/src/main/java/org/apache/thrift/TUnion.java @@ -17,15 +17,14 @@ */ package org.apache.thrift; +import java.nio.ByteBuffer; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; -import java.nio.ByteBuffer; -import org.apache.thrift.TUnion.TUnionStandardScheme; import org.apache.thrift.protocol.TField; import org.apache.thrift.protocol.TProtocol; import org.apache.thrift.protocol.TProtocolException; @@ -211,7 +210,7 @@ public TUnionStandardScheme getScheme() { } } - public static class TUnionStandardScheme extends StandardScheme<TUnion> { + private static class TUnionStandardScheme extends StandardScheme<TUnion> { @Override public void read(TProtocol iprot, TUnion struct) throws TException { @@ -250,12 +249,12 @@ public void write(TProtocol oprot, TUnion struct) throws TException { } private static class TUnionTupleSchemeFactory implements SchemeFactory { - public TUnionStandardScheme getScheme() { - return new TUnionStandardScheme(); + public TUnionTupleScheme getScheme() { + return new TUnionTupleScheme(); } } - public static class TUnionTupleScheme extends TupleScheme<TUnion> { + private static class TUnionTupleScheme extends TupleScheme<TUnion> { @Override public void read(TProtocol iprot, TUnion struct) throws TException { diff --git a/app/src/main/java/org/apache/thrift/async/TAsyncClientManager.java b/app/src/main/java/org/apache/thrift/async/TAsyncClientManager.java index 98f7194..c07ccd5 100644 --- a/app/src/main/java/org/apache/thrift/async/TAsyncClientManager.java +++ b/app/src/main/java/org/apache/thrift/async/TAsyncClientManager.java @@ -19,6 +19,7 @@ package org.apache.thrift.async; import java.io.IOException; +import java.io.Serializable; import java.nio.channels.ClosedSelectorException; import java.nio.channels.SelectionKey; import java.nio.channels.Selector; @@ -116,6 +117,12 @@ public void run() { LOGGER.error("Ignoring uncaught exception in SelectThread", exception); } } + + try { + selector.close(); + } catch (IOException ex) { + LOGGER.warn("Could not close selector. This may result in leaked resources!", ex); + } } // Transition methods for ready keys @@ -182,7 +189,7 @@ private void startPendingMethods() { } /** Comparator used in TreeSet */ - private static class TAsyncMethodCallTimeoutComparator implements Comparator<TAsyncMethodCall> { + private static class TAsyncMethodCallTimeoutComparator implements Comparator<TAsyncMethodCall>, Serializable { public int compare(TAsyncMethodCall left, TAsyncMethodCall right) { if (left.getTimeoutTimestamp() == right.getTimeoutTimestamp()) { return (int)(left.getSequenceId() - right.getSequenceId()); diff --git a/app/src/main/java/org/apache/thrift/async/TAsyncMethodCall.java b/app/src/main/java/org/apache/thrift/async/TAsyncMethodCall.java index fcd50ea..5c679b6 100644 --- a/app/src/main/java/org/apache/thrift/async/TAsyncMethodCall.java +++ b/app/src/main/java/org/apache/thrift/async/TAsyncMethodCall.java @@ -65,7 +65,8 @@ public static enum State { private final AsyncMethodCallback<T> callback; private final boolean isOneway; private long sequenceId; - + private final long timeout; + private ByteBuffer sizeBuffer; private final byte[] sizeBufferArray = new byte[4]; private ByteBuffer frameBuffer; @@ -79,6 +80,7 @@ protected TAsyncMethodCall(TAsyncClient client, TProtocolFactory protocolFactory this.client = client; this.isOneway = isOneway; this.sequenceId = TAsyncMethodCall.sequenceIdCounter.getAndIncrement(); + this.timeout = client.getTimeout(); } protected State getState() { @@ -102,11 +104,11 @@ public TAsyncClient getClient() { } public boolean hasTimeout() { - return client.hasTimeout(); + return timeout > 0; } public long getTimeoutTimestamp() { - return client.getTimeout() + startTime; + return timeout + startTime; } protected abstract void write_args(TProtocol protocol) throws TException; diff --git a/app/src/main/java/org/apache/thrift/meta_data/FieldMetaData.java b/app/src/main/java/org/apache/thrift/meta_data/FieldMetaData.java index b634291..445f7e4 100644 --- a/app/src/main/java/org/apache/thrift/meta_data/FieldMetaData.java +++ b/app/src/main/java/org/apache/thrift/meta_data/FieldMetaData.java @@ -45,7 +45,7 @@ public FieldMetaData(String name, byte req, FieldValueMetaData vMetaData){ this.valueMetaData = vMetaData; } - public static void addStructMetaDataMap(Class<? extends TBase> sClass, Map<? extends TFieldIdEnum, FieldMetaData> map){ + public static synchronized void addStructMetaDataMap(Class<? extends TBase> sClass, Map<? extends TFieldIdEnum, FieldMetaData> map){ structMap.put(sClass, map); } @@ -55,7 +55,7 @@ public static void addStructMetaDataMap(Class<? extends TBase> sClass, Map<? ext * * @param sClass The TBase class for which the metadata map is requested */ - public static Map<? extends TFieldIdEnum, FieldMetaData> getStructMetaDataMap(Class<? extends TBase> sClass){ + public static synchronized Map<? extends TFieldIdEnum, FieldMetaData> getStructMetaDataMap(Class<? extends TBase> sClass){ if (!structMap.containsKey(sClass)){ // Load class if it hasn't been loaded try{ sClass.newInstance(); diff --git a/app/src/main/java/org/apache/thrift/protocol/TBase64Utils.java b/app/src/main/java/org/apache/thrift/protocol/TBase64Utils.java index 37a9fd9..abfc965 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TBase64Utils.java +++ b/app/src/main/java/org/apache/thrift/protocol/TBase64Utils.java @@ -56,24 +56,23 @@ static final void encode(byte[] src, int srcOff, int len, byte[] dst, if (len == 3) { dst[dstOff + 1] = (byte)ENCODE_TABLE.charAt( - ((src[srcOff] << 4) + (src[srcOff+1] >> 4)) & 0x3F); + ((src[srcOff] << 4) & 0x30) | ((src[srcOff+1] >> 4) & 0x0F)); dst[dstOff + 2] = (byte)ENCODE_TABLE.charAt( - ((src[srcOff+1] << 2) + (src[srcOff+2] >> 6)) & 0x3F); + ((src[srcOff+1] << 2) & 0x3C) | ((src[srcOff+2] >> 6) & 0x03)); dst[dstOff + 3] = (byte)ENCODE_TABLE.charAt(src[srcOff+2] & 0x3F); } else if (len == 2) { dst[dstOff+1] = (byte)ENCODE_TABLE.charAt( - ((src[srcOff] << 4) + (src[srcOff+1] >> 4)) & 0x3F); + ((src[srcOff] << 4) & 0x30) | ((src[srcOff+1] >> 4) & 0x0F)); dst[dstOff + 2] = - (byte)ENCODE_TABLE.charAt((src[srcOff+1] << 2) & 0x3F); - + (byte)ENCODE_TABLE.charAt((src[srcOff+1] << 2) & 0x3C); } else { // len == 1) { dst[dstOff + 1] = - (byte)ENCODE_TABLE.charAt((src[srcOff] << 4) & 0x3F); + (byte)ENCODE_TABLE.charAt((src[srcOff] << 4) & 0x30); } } diff --git a/app/src/main/java/org/apache/thrift/protocol/TBinaryProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TBinaryProtocol.java index d0d993b..65b3353 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TBinaryProtocol.java +++ b/app/src/main/java/org/apache/thrift/protocol/TBinaryProtocol.java @@ -31,44 +31,53 @@ */ public class TBinaryProtocol extends TProtocol { private static final TStruct ANONYMOUS_STRUCT = new TStruct(); + private static final long NO_LENGTH_LIMIT = -1; protected static final int VERSION_MASK = 0xffff0000; protected static final int VERSION_1 = 0x80010000; - protected boolean strictRead_ = false; - protected boolean strictWrite_ = true; + /** + * The maximum number of bytes to read from the transport for + * variable-length fields (such as strings or binary) or {@link #NO_LENGTH_LIMIT} for + * unlimited. + */ + private final long stringLengthLimit_; + + /** + * The maximum number of elements to read from the network for + * containers (maps, sets, lists), or {@link #NO_LENGTH_LIMIT} for unlimited. + */ + private final long containerLengthLimit_; - protected int readLength_; - protected boolean checkReadLength_ = false; + protected boolean strictRead_; + protected boolean strictWrite_; /** * Factory */ public static class Factory implements TProtocolFactory { - protected boolean strictRead_ = false; - protected boolean strictWrite_ = true; - protected int readLength_; + protected long stringLengthLimit_; + protected long containerLengthLimit_; + protected boolean strictRead_; + protected boolean strictWrite_; public Factory() { this(false, true); } public Factory(boolean strictRead, boolean strictWrite) { - this(strictRead, strictWrite, 0); + this(strictRead, strictWrite, NO_LENGTH_LIMIT, NO_LENGTH_LIMIT); } - public Factory(boolean strictRead, boolean strictWrite, int readLength) { + public Factory(boolean strictRead, boolean strictWrite, long stringLengthLimit, long containerLengthLimit) { + stringLengthLimit_ = stringLengthLimit; + containerLengthLimit_ = containerLengthLimit; strictRead_ = strictRead; strictWrite_ = strictWrite; - readLength_ = readLength; } public TProtocol getProtocol(TTransport trans) { - TBinaryProtocol proto = new TBinaryProtocol(trans, strictRead_, strictWrite_); - if (readLength_ != 0) { - proto.setReadLength(readLength_); - } - return proto; + return new TBinaryProtocol(trans, stringLengthLimit_, containerLengthLimit_, strictRead_, strictWrite_); } } @@ -80,7 +89,13 @@ public TBinaryProtocol(TTransport trans) { } public TBinaryProtocol(TTransport trans, boolean strictRead, boolean strictWrite) { + this(trans, NO_LENGTH_LIMIT, NO_LENGTH_LIMIT, strictRead, strictWrite); + } + + public TBinaryProtocol(TTransport trans, long stringLengthLimit, long containerLengthLimit, boolean strictRead, boolean strictWrite) { super(trans); + stringLengthLimit_ = stringLengthLimit; + containerLengthLimit_ = containerLengthLimit; strictRead_ = strictRead; strictWrite_ = strictWrite; } @@ -233,19 +248,25 @@ public TField readFieldBegin() throws TException { public void readFieldEnd() {} public TMap readMapBegin() throws TException { - return new TMap(readByte(), readByte(), readI32()); + TMap map = new TMap(readByte(), readByte(), readI32()); + checkContainerReadLength(map.size); + return map; } public void readMapEnd() {} public TList readListBegin() throws TException { - return new TList(readByte(), readI32()); + TList list = new TList(readByte(), readI32()); + checkContainerReadLength(list.size); + return list; } public void readListEnd() {} public TSet readSetBegin() throws TException { - return new TSet(readByte(), readI32()); + TSet set = new TSet(readByte(), readI32()); + checkContainerReadLength(set.size); + return set; } public void readSetEnd() {} @@ -334,6 +355,12 @@ public double readDouble() throws TException { public String readString() throws TException { int size = readI32(); + checkStringReadLength(size); + if (stringLengthLimit_ > 0 && size > stringLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "String field exceeded string size limit"); + } + if (trans_.getBytesRemainingInBuffer() >= size) { try { String s = new String(trans_.getBuffer(), trans_.getBufferPosition(), size, "UTF-8"); @@ -349,7 +376,6 @@ public String readString() throws TException { public String readStringBody(int size) throws TException { try { - checkReadLength(size); byte[] buf = new byte[size]; trans_.readAll(buf, 0, size); return new String(buf, "UTF-8"); @@ -360,7 +386,11 @@ public String readStringBody(int size) throws TException { public ByteBuffer readBinary() throws TException { int size = readI32(); - checkReadLength(size); + + if (stringLengthLimit_ > 0 && size > stringLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "Binary field exceeded string size limit"); + } if (trans_.getBytesRemainingInBuffer() >= size) { ByteBuffer bb = ByteBuffer.wrap(trans_.getBuffer(), trans_.getBufferPosition(), size); @@ -373,26 +403,29 @@ public ByteBuffer readBinary() throws TException { return ByteBuffer.wrap(buf); } - private int readAll(byte[] buf, int off, int len) throws TException { - checkReadLength(len); - return trans_.readAll(buf, off, len); - } - - public void setReadLength(int readLength) { - readLength_ = readLength; - checkReadLength_ = true; + private void checkStringReadLength(int length) throws TProtocolException { + if (length < 0) { + throw new TProtocolException(TProtocolException.NEGATIVE_SIZE, + "Negative length: " + length); + } + if (stringLengthLimit_ != NO_LENGTH_LIMIT && length > stringLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "Length exceeded max allowed: " + length); + } } - protected void checkReadLength(int length) throws TException { + private void checkContainerReadLength(int length) throws TProtocolException { if (length < 0) { - throw new TException("Negative length: " + length); + throw new TProtocolException(TProtocolException.NEGATIVE_SIZE, + "Negative length: " + length); } - if (checkReadLength_) { - readLength_ -= length; - if (readLength_ < 0) { - throw new TException("Message length exceeded: " + length); - } + if (containerLengthLimit_ != NO_LENGTH_LIMIT && length > containerLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "Length exceeded max allowed: " + length); } } + private int readAll(byte[] buf, int off, int len) throws TException { + return trans_.readAll(buf, off, len); + } } diff --git a/app/src/main/java/org/apache/thrift/protocol/TCompactProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TCompactProtocol.java index 3b1d886..5973fcd 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TCompactProtocol.java +++ b/app/src/main/java/org/apache/thrift/protocol/TCompactProtocol.java @@ -29,15 +29,17 @@ /** * TCompactProtocol2 is the Java implementation of the compact protocol specified - * in THRIFT-110. The fundamental approach to reducing the overhead of + * in THRIFT-110. The fundamental approach to reducing the overhead of * structures is a) use variable-length integers all over the place and b) make - * use of unused bits wherever possible. Your savings will obviously vary - * based on the specific makeup of your structs, but in general, the more + * use of unused bits wherever possible. Your savings will obviously vary + * based on the specific makeup of your structs, but in general, the more * fields, nested structures, short strings and collections, and low-value i32 * and i64 fields you have, the more benefit you'll see. */ public class TCompactProtocol extends TProtocol { + private final static long NO_LENGTH_LIMIT = -1; + private final static TStruct ANONYMOUS_STRUCT = new TStruct(""); private final static TField TSTOP = new TField("", TType.STOP, (short)0); @@ -62,10 +64,24 @@ public class TCompactProtocol extends TProtocol { * TProtocolFactory that produces TCompactProtocols. */ public static class Factory implements TProtocolFactory { - public Factory() {} + private final long stringLengthLimit_; + private final long containerLengthLimit_; + + public Factory() { + this(NO_LENGTH_LIMIT, NO_LENGTH_LIMIT); + } + + public Factory(long stringLengthLimit) { + this(stringLengthLimit, NO_LENGTH_LIMIT); + } + + public Factory(long stringLengthLimit, long containerLengthLimit) { + this.containerLengthLimit_ = containerLengthLimit; + this.stringLengthLimit_ = stringLengthLimit; + } public TProtocol getProtocol(TTransport trans) { - return new TCompactProtocol(trans); + return new TCompactProtocol(trans, stringLengthLimit_, containerLengthLimit_); } } @@ -73,6 +89,7 @@ public TProtocol getProtocol(TTransport trans) { private static final byte VERSION = 1; private static final byte VERSION_MASK = 0x1f; // 0001 1111 private static final byte TYPE_MASK = (byte)0xE0; // 1110 0000 + private static final byte TYPE_BITS = 0x07; // 0000 0111 private static final int TYPE_SHIFT_AMOUNT = 5; /** @@ -93,7 +110,7 @@ private static class Types { public static final byte STRUCT = 0x0C; } - /** + /** * Used to keep track of the last field for the current and previous structs, * so we can do the delta stuff. */ @@ -102,24 +119,65 @@ private static class Types { private short lastFieldId_ = 0; /** - * If we encounter a boolean field begin, save the TField here so it can + * If we encounter a boolean field begin, save the TField here so it can * have the value incorporated. */ private TField booleanField_ = null; /** - * If we read a field header, and it's a boolean field, save the boolean + * If we read a field header, and it's a boolean field, save the boolean * value here so that readBool can use it. */ private Boolean boolValue_ = null; + /** + * The maximum number of bytes to read from the transport for + * variable-length fields (such as strings or binary) or {@link #NO_LENGTH_LIMIT} for + * unlimited. + */ + private final long stringLengthLimit_; + + /** + * The maximum number of elements to read from the network for + * containers (maps, sets, lists), or {@link #NO_LENGTH_LIMIT} for unlimited. + */ + private final long containerLengthLimit_; + /** * Create a TCompactProtocol. * * @param transport the TTransport object to read from or write to. + * @param stringLengthLimit the maximum number of bytes to read for + * variable-length fields. + * @param containerLengthLimit the maximum number of elements to read + * for containers. */ - public TCompactProtocol(TTransport transport) { + public TCompactProtocol(TTransport transport, long stringLengthLimit, long containerLengthLimit) { super(transport); + this.stringLengthLimit_ = stringLengthLimit; + this.containerLengthLimit_ = containerLengthLimit; + } + + /** + * Create a TCompactProtocol. + * + * @param transport the TTransport object to read from or write to. + * @param stringLengthLimit the maximum number of bytes to read for + * variable-length fields. + * @deprecated Use constructor specifying both string limit and container limit instead + */ + @Deprecated + public TCompactProtocol(TTransport transport, long stringLengthLimit) { + this(transport, stringLengthLimit, NO_LENGTH_LIMIT); + } + + /** + * Create a TCompactProtocol. + * + * @param transport the TTransport object to read from or write to. + */ + public TCompactProtocol(TTransport transport) { + this(transport, NO_LENGTH_LIMIT, NO_LENGTH_LIMIT); } @Override @@ -144,7 +202,7 @@ public void writeMessageBegin(TMessage message) throws TException { } /** - * Write a struct begin. This doesn't actually put anything on the wire. We + * Write a struct begin. This doesn't actually put anything on the wire. We * use it as an opportunity to put special placeholder markers on the field * stack so we can get the field id deltas correct. */ @@ -167,7 +225,7 @@ public void writeStructEnd() throws TException { * difference between the current field id and the last one is small (< 15), * then the field id will be encoded in the 4 MSB as a delta. Otherwise, the * field id will follow the type header as a zigzag varint. - */ + */ public void writeFieldBegin(TField field) throws TException { if (field.type == TType.BOOL) { // we want to possibly include the value, so we'll wait. @@ -178,8 +236,8 @@ public void writeFieldBegin(TField field) throws TException { } /** - * The workhorse of writeFieldBegin. It has the option of doing a - * 'type override' of the type header. This is used specifically in the + * The workhorse of writeFieldBegin. It has the option of doing a + * 'type override' of the type header. This is used specifically in the * boolean field case. */ private void writeFieldBeginInternal(TField field, byte typeOverride) throws TException { @@ -210,7 +268,7 @@ public void writeFieldStop() throws TException { } /** - * Write a map header. If the map is empty, omit the key and value type + * Write a map header. If the map is empty, omit the key and value type * headers, as we don't need any additional information to skip it. */ public void writeMapBegin(TMap map) throws TException { @@ -221,8 +279,8 @@ public void writeMapBegin(TMap map) throws TException { writeByteDirect(getCompactType(map.keyType) << 4 | getCompactType(map.valueType)); } } - - /** + + /** * Write a list header. */ public void writeListBegin(TList list) throws TException { @@ -237,9 +295,9 @@ public void writeSetBegin(TSet set) throws TException { } /** - * Write a boolean value. Potentially, this could be a boolean field, in + * Write a boolean value. Potentially, this could be a boolean field, in * which case the field header info isn't written yet. If so, decide what the - * right type header is for the value and then write the field header. + * right type header is for the value and then write the field header. * Otherwise, write a single byte. */ public void writeBool(boolean b) throws TException { @@ -253,7 +311,7 @@ public void writeBool(boolean b) throws TException { } } - /** + /** * Write a byte. Nothing to see here! */ public void writeByte(byte b) throws TException { @@ -283,7 +341,7 @@ public void writeI64(long i64) throws TException { /** * Write a double to the wire as 8 bytes. - */ + */ public void writeDouble(double dub) throws TException { byte[] data = new byte[]{0, 0, 0, 0, 0, 0, 0, 0}; fixedLongToBytes(Double.doubleToLongBits(dub), data, 0); @@ -303,7 +361,7 @@ public void writeString(String str) throws TException { } /** - * Write a byte array, using a varint for the size. + * Write a byte array, using a varint for the size. */ public void writeBinary(ByteBuffer bin) throws TException { int length = bin.limit() - bin.position(); @@ -316,9 +374,9 @@ private void writeBinary(byte[] buf, int offset, int length) throws TException { } // - // These methods are called by structs, but don't actually have any wire + // These methods are called by structs, but don't actually have any wire // output or purpose. - // + // public void writeMessageEnd() throws TException {} public void writeMapEnd() throws TException {} @@ -331,7 +389,7 @@ public void writeFieldEnd() throws TException {} // /** - * Abstract method for writing the start of lists and sets. List and sets on + * Abstract method for writing the start of lists and sets. List and sets on * the wire differ only by the type indicator. */ protected void writeCollectionBegin(byte elemType, int size) throws TException { @@ -384,7 +442,7 @@ private void writeVarint64(long n) throws TException { } /** - * Convert l into a zigzag long. This allows negative numbers to be + * Convert l into a zigzag long. This allows negative numbers to be * represented compactly as a varint. */ private long longToZigzag(long l) { @@ -392,7 +450,7 @@ private long longToZigzag(long l) { } /** - * Convert n into a zigzag int. This allows negative numbers to be + * Convert n into a zigzag int. This allows negative numbers to be * represented compactly as a varint. */ private int intToZigZag(int n) { @@ -400,7 +458,7 @@ private int intToZigZag(int n) { } /** - * Convert a long into little-endian bytes in buf starting at off and going + * Convert a long into little-endian bytes in buf starting at off and going * until off+7. */ private void fixedLongToBytes(long n, byte[] buf, int off) { @@ -414,8 +472,8 @@ private void fixedLongToBytes(long n, byte[] buf, int off) { buf[off+7] = (byte)((n >> 56) & 0xff); } - /** - * Writes a byte without any possibility of all that field header nonsense. + /** + * Writes a byte without any possibility of all that field header nonsense. * Used internally by other writing methods that know they need to write a byte. */ private byte[] byteDirectBuffer = new byte[1]; @@ -424,7 +482,7 @@ private void writeByteDirect(byte b) throws TException { trans_.write(byteDirectBuffer); } - /** + /** * Writes a byte without any possibility of all that field header nonsense. */ private void writeByteDirect(int n) throws TException { @@ -432,12 +490,12 @@ private void writeByteDirect(int n) throws TException { } - // + // // Reading methods. - // + // /** - * Read a message header. + * Read a message header. */ public TMessage readMessageBegin() throws TException { byte protocolId = readByte(); @@ -449,7 +507,7 @@ public TMessage readMessageBegin() throws TException { if (version != VERSION) { throw new TProtocolException("Expected version " + VERSION + " but got " + version); } - byte type = (byte)((versionAndType >> TYPE_SHIFT_AMOUNT) & 0x03); + byte type = (byte)((versionAndType >> TYPE_SHIFT_AMOUNT) & TYPE_BITS); int seqid = readVarint32(); String messageName = readString(); return new TMessage(messageName, type, seqid); @@ -466,16 +524,16 @@ public TStruct readStructBegin() throws TException { } /** - * Doesn't actually consume any wire data, just removes the last field for + * Doesn't actually consume any wire data, just removes the last field for * this struct from the field stack. */ public void readStructEnd() throws TException { // consume the last field we read off the wire. lastFieldId_ = lastField_.pop(); } - + /** - * Read a field header off the wire. + * Read a field header off the wire. */ public TField readFieldBegin() throws TException { byte type = readByte(); @@ -503,26 +561,27 @@ public TField readFieldBegin() throws TException { if (isBoolType(type)) { // save the boolean value in a special instance variable. boolValue_ = (byte)(type & 0x0f) == Types.BOOLEAN_TRUE ? Boolean.TRUE : Boolean.FALSE; - } + } // push the new field onto the field stack so we can keep the deltas going. lastFieldId_ = field.id; return field; } - /** + /** * Read a map header off the wire. If the size is zero, skip reading the key * and value type. This means that 0-length maps will yield TMaps without the * "correct" types. */ public TMap readMapBegin() throws TException { int size = readVarint32(); + checkContainerReadLength(size); byte keyAndValueType = size == 0 ? 0 : readByte(); return new TMap(getTType((byte)(keyAndValueType >> 4)), getTType((byte)(keyAndValueType & 0xf)), size); } /** - * Read a list header off the wire. If the list size is 0-14, the size will + * Read a list header off the wire. If the list size is 0-14, the size will * be packed into the element type header. If it's a longer list, the 4 MSB * of the element type header will be 0xF, and a varint will follow with the * true size. @@ -533,12 +592,13 @@ public TList readListBegin() throws TException { if (size == 15) { size = readVarint32(); } + checkContainerReadLength(size); byte type = getTType(size_and_type); return new TList(type, size); } /** - * Read a set header off the wire. If the set size is 0-14, the size will + * Read a set header off the wire. If the set size is 0-14, the size will * be packed into the element type header. If it's a longer set, the 4 MSB * of the element type header will be 0xF, and a varint will follow with the * true size. @@ -612,6 +672,7 @@ public double readDouble() throws TException { */ public String readString() throws TException { int length = readVarint32(); + checkStringReadLength(length); if (length == 0) { return ""; @@ -631,19 +692,26 @@ public String readString() throws TException { } /** - * Read a byte[] from the wire. + * Read a byte[] from the wire. */ public ByteBuffer readBinary() throws TException { int length = readVarint32(); + checkStringReadLength(length); if (length == 0) return ByteBuffer.wrap(new byte[0]); + if (trans_.getBytesRemainingInBuffer() >= length) { + ByteBuffer bb = ByteBuffer.wrap(trans_.getBuffer(), trans_.getBufferPosition(), length); + trans_.consumeBuffer(length); + return bb; + } + byte[] buf = new byte[length]; trans_.readAll(buf, 0, length); return ByteBuffer.wrap(buf); } /** - * Read a byte[] of a known length from the wire. + * Read a byte[] of a known length from the wire. */ private byte[] readBinary(int length) throws TException { if (length == 0) return new byte[0]; @@ -653,8 +721,30 @@ private byte[] readBinary(int length) throws TException { return buf; } + private void checkStringReadLength(int length) throws TProtocolException { + if (length < 0) { + throw new TProtocolException(TProtocolException.NEGATIVE_SIZE, + "Negative length: " + length); + } + if (stringLengthLimit_ != NO_LENGTH_LIMIT && length > stringLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "Length exceeded max allowed: " + length); + } + } + + private void checkContainerReadLength(int length) throws TProtocolException { + if (length < 0) { + throw new TProtocolException(TProtocolException.NEGATIVE_SIZE, + "Negative length: " + length); + } + if (containerLengthLimit_ != NO_LENGTH_LIMIT && length > containerLengthLimit_) { + throw new TProtocolException(TProtocolException.SIZE_LIMIT, + "Length exceeded max allowed: " + length); + } + } + // - // These methods are here for the struct to call, but don't have any wire + // These methods are here for the struct to call, but don't have any wire // encoding. // public void readMessageEnd() throws TException {} @@ -698,7 +788,7 @@ private int readVarint32() throws TException { } /** - * Read an i64 from the wire as a proper varint. The MSB of each byte is set + * Read an i64 from the wire as a proper varint. The MSB of each byte is set * if there is another byte to follow. This can read up to 10 bytes. */ private long readVarint64() throws TException { @@ -738,7 +828,7 @@ private int zigzagToInt(int n) { return (n >>> 1) ^ -(n & 1); } - /** + /** * Convert from zigzag long to long. */ private long zigzagToLong(long n) { @@ -746,7 +836,7 @@ private long zigzagToLong(long n) { } /** - * Note that it's important that the mask bytes are long literals, + * Note that it's important that the mask bytes are long literals, * otherwise they'll default to ints, and when you shift an int left 56 bits, * you just get a messed up int. */ @@ -772,7 +862,7 @@ private boolean isBoolType(byte b) { } /** - * Given a TCompactProtocol.Types constant, convert it to its corresponding + * Given a TCompactProtocol.Types constant, convert it to its corresponding * TType value. */ private byte getTType(byte type) throws TProtocolException { diff --git a/app/src/main/java/org/apache/thrift/protocol/TField.java b/app/src/main/java/org/apache/thrift/protocol/TField.java index 03affda..31331bb 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TField.java +++ b/app/src/main/java/org/apache/thrift/protocol/TField.java @@ -42,7 +42,25 @@ public String toString() { return "<TField name:'" + name + "' type:" + type + " field-id:" + id + ">"; } - public boolean equals(TField otherField) { + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + id; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + result = prime * result + type; + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + TField otherField = (TField) obj; return type == otherField.type && id == otherField.id; } } diff --git a/app/src/main/java/org/apache/thrift/protocol/TJSONProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TJSONProtocol.java index f07a4a7..f51322c 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TJSONProtocol.java +++ b/app/src/main/java/org/apache/thrift/protocol/TJSONProtocol.java @@ -42,9 +42,16 @@ public class TJSONProtocol extends TProtocol { * Factory for JSON protocol objects */ public static class Factory implements TProtocolFactory { + protected boolean fieldNamesAsString_ = false; + + public Factory() {} + + public Factory(boolean fieldNamesAsString) { + fieldNamesAsString_ = fieldNamesAsString; + } public TProtocol getProtocol(TTransport trans) { - return new TJSONProtocol(trans); + return new TJSONProtocol(trans, fieldNamesAsString_); } } @@ -70,10 +77,10 @@ public TProtocol getProtocol(TTransport trans) { 1, 1,'"', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 2 }; - private static final String ESCAPE_CHARS = "\"\\bfnrt"; + private static final String ESCAPE_CHARS = "\"\\/bfnrt"; private static final byte[] ESCAPE_CHAR_VALS = { - '"', '\\', '\b', '\f', '\n', '\r', '\t', + '"', '\\', '/', '\b', '\f', '\n', '\r', '\t', }; private static final int DEF_STRING_SIZE = 16; @@ -285,6 +292,9 @@ protected byte peek() throws TException { // Reader that manages a 1-byte buffer private LookaheadReader reader_ = new LookaheadReader(); + // Write out the TField names as a string instead of the default integer value + private boolean fieldNamesAsString_ = false; + // Push a new JSON context onto the stack. private void pushContext(JSONBaseContext c) { contextStack_.push(context_); @@ -303,6 +313,11 @@ public TJSONProtocol(TTransport trans) { super(trans); } + public TJSONProtocol(TTransport trans, boolean fieldNamesAsString) { + super(trans); + fieldNamesAsString_ = fieldNamesAsString; + } + @Override public void reset() { contextStack_.clear(); @@ -421,7 +436,9 @@ private void writeJSONDouble(double num) throws TException { special = true; } break; - } + default: + break; + } boolean escapeNum = special || context_.escapeNum(); if (escapeNum) { @@ -513,7 +530,11 @@ public void writeStructEnd() throws TException { @Override public void writeFieldBegin(TField field) throws TException { - writeJSONInteger(field.id); + if (fieldNamesAsString_) { + writeString(field.name); + } else { + writeJSONInteger(field.id); + } writeJSONObjectStart(); writeJSONString(getTypeNameForTypeID(field.type)); } diff --git a/app/src/main/java/org/apache/thrift/protocol/TMessage.java b/app/src/main/java/org/apache/thrift/protocol/TMessage.java index 1438b11..f13b8ca 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TMessage.java +++ b/app/src/main/java/org/apache/thrift/protocol/TMessage.java @@ -44,14 +44,33 @@ public String toString() { } @Override - public boolean equals(Object other) { - if (other instanceof TMessage) { - return equals((TMessage) other); - } - return false; + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((name == null) ? 0 : name.hashCode()); + result = prime * result + seqid; + result = prime * result + type; + return result; } - public boolean equals(TMessage other) { - return name.equals(other.name) && type == other.type && seqid == other.seqid; + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + TMessage other = (TMessage) obj; + if (name == null) { + if (other.name != null) + return false; + } else if (!name.equals(other.name)) + return false; + if (seqid != other.seqid) + return false; + if (type != other.type) + return false; + return true; } } diff --git a/app/src/main/java/org/apache/thrift/protocol/TMultiplexedProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TMultiplexedProtocol.java new file mode 100644 index 0000000..3535274 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/protocol/TMultiplexedProtocol.java @@ -0,0 +1,91 @@ +/* + * 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.thrift.protocol; + +import org.apache.thrift.TException; + +/** + * <code>TMultiplexedProtocol</code> is a protocol-independent concrete decorator + * that allows a Thrift client to communicate with a multiplexing Thrift server, + * by prepending the service name to the function name during function calls. + * + * <p>NOTE: THIS IS NOT USED BY SERVERS. On the server, use {@link org.apache.thrift.TMultiplexedProcessor TMultiplexedProcessor} to handle requests + * from a multiplexing client. + * + * <p>This example uses a single socket transport to invoke two services: + * + * <blockquote><code> + * TSocket transport = new TSocket("localhost", 9090);<br/> + * transport.open();<br/> + *<br/> + * TBinaryProtocol protocol = new TBinaryProtocol(transport);<br/> + *<br/> + * TMultiplexedProtocol mp = new TMultiplexedProtocol(protocol, "Calculator");<br/> + * Calculator.Client service = new Calculator.Client(mp);<br/> + *<br/> + * TMultiplexedProtocol mp2 = new TMultiplexedProtocol(protocol, "WeatherReport");<br/> + * WeatherReport.Client service2 = new WeatherReport.Client(mp2);<br/> + *<br/> + * System.out.println(service.add(2,2));<br/> + * System.out.println(service2.getTemperature());<br/> + * </code></blockquote> + * + * @see org.apache.thrift.protocol.TProtocolDecorator + */ +public class TMultiplexedProtocol extends TProtocolDecorator { + + /** Used to delimit the service name from the function name */ + public static final String SEPARATOR = ":"; + + private final String SERVICE_NAME; + + /** + * Wrap the specified protocol, allowing it to be used to communicate with a + * multiplexing server. The <code>serviceName</code> is required as it is + * prepended to the message header so that the multiplexing server can broker + * the function call to the proper service. + * + * @param protocol Your communication protocol of choice, e.g. <code>TBinaryProtocol</code>. + * @param serviceName The service name of the service communicating via this protocol. + */ + public TMultiplexedProtocol(TProtocol protocol, String serviceName) { + super(protocol); + SERVICE_NAME = serviceName; + } + + /** + * Prepends the service name to the function name, separated by TMultiplexedProtocol.SEPARATOR. + * + * @param tMessage The original message. + * @throws TException Passed through from wrapped <code>TProtocol</code> instance. + */ + @Override + public void writeMessageBegin(TMessage tMessage) throws TException { + if (tMessage.type == TMessageType.CALL || tMessage.type == TMessageType.ONEWAY) { + super.writeMessageBegin(new TMessage( + SERVICE_NAME + SEPARATOR + tMessage.name, + tMessage.type, + tMessage.seqid + )); + } else { + super.writeMessageBegin(tMessage); + } + } +} diff --git a/app/src/main/java/org/apache/thrift/protocol/TProtocolDecorator.java b/app/src/main/java/org/apache/thrift/protocol/TProtocolDecorator.java new file mode 100644 index 0000000..2d29cd2 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/protocol/TProtocolDecorator.java @@ -0,0 +1,213 @@ +/* + * 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.thrift.protocol; + +import org.apache.thrift.TException; + +import java.nio.ByteBuffer; + +/** + * <code>TProtocolDecorator</code> forwards all requests to an enclosed + * <code>TProtocol</code> instance, providing a way to author concise + * concrete decorator subclasses. While it has no abstract methods, it + * is marked abstract as a reminder that by itself, it does not modify + * the behaviour of the enclosed <code>TProtocol</code>. + * + * <p>See p.175 of Design Patterns (by Gamma et al.)</p> + * + * @see org.apache.thrift.protocol.TMultiplexedProtocol + */ +public abstract class TProtocolDecorator extends TProtocol { + + private final TProtocol concreteProtocol; + + /** + * Encloses the specified protocol. + * @param protocol All operations will be forward to this protocol. Must be non-null. + */ + public TProtocolDecorator(TProtocol protocol) { + super(protocol.getTransport()); + concreteProtocol = protocol; + } + + public void writeMessageBegin(TMessage tMessage) throws TException { + concreteProtocol.writeMessageBegin(tMessage); + } + + public void writeMessageEnd() throws TException { + concreteProtocol.writeMessageEnd(); + } + + public void writeStructBegin(TStruct tStruct) throws TException { + concreteProtocol.writeStructBegin(tStruct); + } + + public void writeStructEnd() throws TException { + concreteProtocol.writeStructEnd(); + } + + public void writeFieldBegin(TField tField) throws TException { + concreteProtocol.writeFieldBegin(tField); + } + + public void writeFieldEnd() throws TException { + concreteProtocol.writeFieldEnd(); + } + + public void writeFieldStop() throws TException { + concreteProtocol.writeFieldStop(); + } + + public void writeMapBegin(TMap tMap) throws TException { + concreteProtocol.writeMapBegin(tMap); + } + + public void writeMapEnd() throws TException { + concreteProtocol.writeMapEnd(); + } + + public void writeListBegin(TList tList) throws TException { + concreteProtocol.writeListBegin(tList); + } + + public void writeListEnd() throws TException { + concreteProtocol.writeListEnd(); + } + + public void writeSetBegin(TSet tSet) throws TException { + concreteProtocol.writeSetBegin(tSet); + } + + public void writeSetEnd() throws TException { + concreteProtocol.writeSetEnd(); + } + + public void writeBool(boolean b) throws TException { + concreteProtocol.writeBool(b); + } + + public void writeByte(byte b) throws TException { + concreteProtocol.writeByte(b); + } + + public void writeI16(short i) throws TException { + concreteProtocol.writeI16(i); + } + + public void writeI32(int i) throws TException { + concreteProtocol.writeI32(i); + } + + public void writeI64(long l) throws TException { + concreteProtocol.writeI64(l); + } + + public void writeDouble(double v) throws TException { + concreteProtocol.writeDouble(v); + } + + public void writeString(String s) throws TException { + concreteProtocol.writeString(s); + } + + public void writeBinary(ByteBuffer buf) throws TException { + concreteProtocol.writeBinary(buf); + } + + public TMessage readMessageBegin() throws TException { + return concreteProtocol.readMessageBegin(); + } + + public void readMessageEnd() throws TException { + concreteProtocol.readMessageEnd(); + } + + public TStruct readStructBegin() throws TException { + return concreteProtocol.readStructBegin(); + } + + public void readStructEnd() throws TException { + concreteProtocol.readStructEnd(); + } + + public TField readFieldBegin() throws TException { + return concreteProtocol.readFieldBegin(); + } + + public void readFieldEnd() throws TException { + concreteProtocol.readFieldEnd(); + } + + public TMap readMapBegin() throws TException { + return concreteProtocol.readMapBegin(); + } + + public void readMapEnd() throws TException { + concreteProtocol.readMapEnd(); + } + + public TList readListBegin() throws TException { + return concreteProtocol.readListBegin(); + } + + public void readListEnd() throws TException { + concreteProtocol.readListEnd(); + } + + public TSet readSetBegin() throws TException { + return concreteProtocol.readSetBegin(); + } + + public void readSetEnd() throws TException { + concreteProtocol.readSetEnd(); + } + + public boolean readBool() throws TException { + return concreteProtocol.readBool(); + } + + public byte readByte() throws TException { + return concreteProtocol.readByte(); + } + + public short readI16() throws TException { + return concreteProtocol.readI16(); + } + + public int readI32() throws TException { + return concreteProtocol.readI32(); + } + + public long readI64() throws TException { + return concreteProtocol.readI64(); + } + + public double readDouble() throws TException { + return concreteProtocol.readDouble(); + } + + public String readString() throws TException { + return concreteProtocol.readString(); + } + + public ByteBuffer readBinary() throws TException { + return concreteProtocol.readBinary(); + } +} diff --git a/app/src/main/java/org/apache/thrift/protocol/TProtocolException.java b/app/src/main/java/org/apache/thrift/protocol/TProtocolException.java index 248815b..870f1b9 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TProtocolException.java +++ b/app/src/main/java/org/apache/thrift/protocol/TProtocolException.java @@ -35,6 +35,7 @@ public class TProtocolException extends TException { public static final int SIZE_LIMIT = 3; public static final int BAD_VERSION = 4; public static final int NOT_IMPLEMENTED = 5; + public static final int DEPTH_LIMIT = 6; protected int type_ = UNKNOWN; diff --git a/app/src/main/java/org/apache/thrift/protocol/TSimpleJSONProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TSimpleJSONProtocol.java index 33cad24..ffa139a 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TSimpleJSONProtocol.java +++ b/app/src/main/java/org/apache/thrift/protocol/TSimpleJSONProtocol.java @@ -45,13 +45,13 @@ public TProtocol getProtocol(TTransport trans) { } } - public static final byte[] COMMA = new byte[] {','}; - public static final byte[] COLON = new byte[] {':'}; - public static final byte[] LBRACE = new byte[] {'{'}; - public static final byte[] RBRACE = new byte[] {'}'}; - public static final byte[] LBRACKET = new byte[] {'['}; - public static final byte[] RBRACKET = new byte[] {']'}; - public static final char QUOTE = '"'; + private static final byte[] COMMA = new byte[] {','}; + private static final byte[] COLON = new byte[] {':'}; + private static final byte[] LBRACE = new byte[] {'{'}; + private static final byte[] RBRACE = new byte[] {'}'}; + private static final byte[] LBRACKET = new byte[] {'['}; + private static final byte[] RBRACKET = new byte[] {']'}; + private static final char QUOTE = '"'; private static final TStruct ANONYMOUS_STRUCT = new TStruct(); private static final TField ANONYMOUS_FIELD = new TField(); @@ -59,9 +59,17 @@ public TProtocol getProtocol(TTransport trans) { private static final TSet EMPTY_SET = new TSet(); private static final TList EMPTY_LIST = new TList(); private static final TMap EMPTY_MAP = new TMap(); + private static final String LIST = "list"; + private static final String SET = "set"; + private static final String MAP = "map"; protected class Context { protected void write() throws TException {} + + /** + * Returns whether the current value is a key in a map + */ + protected boolean isMapKey() { return false; } } protected class ListContext extends Context { @@ -91,6 +99,22 @@ protected void write() throws TException { } } + protected class MapContext extends StructContext { + protected boolean isKey = true; + + @Override + protected void write() throws TException { + super.write(); + isKey = !isKey; + } + + protected boolean isMapKey() { + // we want to coerce map keys to json strings regardless + // of their type + return isKey; + } + } + protected final Context BASE_CONTEXT = new Context(); /** @@ -118,6 +142,15 @@ protected void popWriteContext() { writeContext_ = writeContextStack_.pop(); } + /** + * Used to make sure that we are not encountering a map whose keys are containers + */ + protected void assertContextIsNotMapKey(String invalidKeyType) throws CollectionMapKeyException { + if (writeContext_.isMapKey()) { + throw new CollectionMapKeyException("Cannot serialize a map with keys that are of type " + invalidKeyType); + } + } + /** * Constructor */ @@ -159,9 +192,10 @@ public void writeFieldEnd() {} public void writeFieldStop() {} public void writeMapBegin(TMap map) throws TException { + assertContextIsNotMapKey(MAP); writeContext_.write(); trans_.write(LBRACE); - pushWriteContext(new StructContext()); + pushWriteContext(new MapContext()); // No metadata! } @@ -171,6 +205,7 @@ public void writeMapEnd() throws TException { } public void writeListBegin(TList list) throws TException { + assertContextIsNotMapKey(LIST); writeContext_.write(); trans_.write(LBRACKET); pushWriteContext(new ListContext()); @@ -183,6 +218,7 @@ public void writeListEnd() throws TException { } public void writeSetBegin(TSet set) throws TException { + assertContextIsNotMapKey(SET); writeContext_.write(); trans_.write(LBRACKET); pushWriteContext(new ListContext()); @@ -207,8 +243,12 @@ public void writeI16(short i16) throws TException { } public void writeI32(int i32) throws TException { - writeContext_.write(); - _writeStringData(Integer.toString(i32)); + if(writeContext_.isMapKey()) { + writeString(Integer.toString(i32)); + } else { + writeContext_.write(); + _writeStringData(Integer.toString(i32)); + } } public void _writeStringData(String s) throws TException { @@ -221,13 +261,21 @@ public void _writeStringData(String s) throws TException { } public void writeI64(long i64) throws TException { - writeContext_.write(); - _writeStringData(Long.toString(i64)); + if(writeContext_.isMapKey()) { + writeString(Long.toString(i64)); + } else { + writeContext_.write(); + _writeStringData(Long.toString(i64)); + } } public void writeDouble(double dub) throws TException { - writeContext_.write(); - _writeStringData(Double.toString(dub)); + if(writeContext_.isMapKey()) { + writeString(Double.toString(dub)); + } else { + writeContext_.write(); + _writeStringData(Double.toString(dub)); + } } public void writeString(String str) throws TException { @@ -382,4 +430,9 @@ public ByteBuffer readBinary() throws TException { return ByteBuffer.wrap(new byte[0]); } + public static class CollectionMapKeyException extends TException { + public CollectionMapKeyException(String message) { + super(message); + } + } } diff --git a/app/src/main/java/org/apache/thrift/protocol/TTupleProtocol.java b/app/src/main/java/org/apache/thrift/protocol/TTupleProtocol.java index 14d50a6..74f5226 100644 --- a/app/src/main/java/org/apache/thrift/protocol/TTupleProtocol.java +++ b/app/src/main/java/org/apache/thrift/protocol/TTupleProtocol.java @@ -86,7 +86,7 @@ public static BitSet fromByteArray(byte[] bytes) { * @return a byte array of at least length 1 */ public static byte[] toByteArray(BitSet bits, int vectorWidth) { - byte[] bytes = new byte[vectorWidth / 8 + 1]; + byte[] bytes = new byte[(int) Math.ceil(vectorWidth/8.0)]; for (int i = 0; i < bits.length(); i++) { if (bits.get(i)) { bytes[bytes.length - i / 8 - 1] |= 1 << (i % 8); diff --git a/app/src/main/java/org/apache/thrift/server/AbstractNonblockingServer.java b/app/src/main/java/org/apache/thrift/server/AbstractNonblockingServer.java new file mode 100644 index 0000000..0c492cc --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/AbstractNonblockingServer.java @@ -0,0 +1,612 @@ +/* + * 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.thrift.server; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.spi.SelectorProvider; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.atomic.AtomicLong; + +import org.apache.thrift.TAsyncProcessor; +import org.apache.thrift.TByteArrayOutputStream; +import org.apache.thrift.TException; +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.transport.TFramedTransport; +import org.apache.thrift.transport.TIOStreamTransport; +import org.apache.thrift.transport.TMemoryInputTransport; +import org.apache.thrift.transport.TNonblockingServerTransport; +import org.apache.thrift.transport.TNonblockingTransport; +import org.apache.thrift.transport.TTransport; +import org.apache.thrift.transport.TTransportException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Provides common methods and classes used by nonblocking TServer + * implementations. + */ +public abstract class AbstractNonblockingServer extends TServer { + protected final Logger LOGGER = LoggerFactory.getLogger(getClass().getName()); + + public static abstract class AbstractNonblockingServerArgs<T extends AbstractNonblockingServerArgs<T>> extends AbstractServerArgs<T> { + public long maxReadBufferBytes = Long.MAX_VALUE; + + public AbstractNonblockingServerArgs(TNonblockingServerTransport transport) { + super(transport); + transportFactory(new TFramedTransport.Factory()); + } + } + + /** + * The maximum amount of memory we will allocate to client IO buffers at a + * time. Without this limit, the server will gladly allocate client buffers + * right into an out of memory exception, rather than waiting. + */ + final long MAX_READ_BUFFER_BYTES; + + /** + * How many bytes are currently allocated to read buffers. + */ + final AtomicLong readBufferBytesAllocated = new AtomicLong(0); + + public AbstractNonblockingServer(AbstractNonblockingServerArgs args) { + super(args); + MAX_READ_BUFFER_BYTES = args.maxReadBufferBytes; + } + + /** + * Begin accepting connections and processing invocations. + */ + public void serve() { + // start any IO threads + if (!startThreads()) { + return; + } + + // start listening, or exit + if (!startListening()) { + return; + } + + setServing(true); + + // this will block while we serve + waitForShutdown(); + + setServing(false); + + // do a little cleanup + stopListening(); + } + + /** + * Starts any threads required for serving. + * + * @return true if everything went ok, false if threads could not be started. + */ + protected abstract boolean startThreads(); + + /** + * A method that will block until when threads handling the serving have been + * shut down. + */ + protected abstract void waitForShutdown(); + + /** + * Have the server transport start accepting connections. + * + * @return true if we started listening successfully, false if something went + * wrong. + */ + protected boolean startListening() { + try { + serverTransport_.listen(); + return true; + } catch (TTransportException ttx) { + LOGGER.error("Failed to start listening on server socket!", ttx); + return false; + } + } + + /** + * Stop listening for connections. + */ + protected void stopListening() { + serverTransport_.close(); + } + + /** + * Perform an invocation. This method could behave several different ways - + * invoke immediately inline, queue for separate execution, etc. + * + * @return true if invocation was successfully requested, which is not a + * guarantee that invocation has completed. False if the request + * failed. + */ + protected abstract boolean requestInvoke(FrameBuffer frameBuffer); + + /** + * An abstract thread that handles selecting on a set of transports and + * {@link FrameBuffer FrameBuffers} associated with selected keys + * corresponding to requests. + */ + protected abstract class AbstractSelectThread extends Thread { + protected final Selector selector; + + // List of FrameBuffers that want to change their selection interests. + protected final Set<FrameBuffer> selectInterestChanges = new HashSet<FrameBuffer>(); + + public AbstractSelectThread() throws IOException { + this.selector = SelectorProvider.provider().openSelector(); + } + + /** + * If the selector is blocked, wake it up. + */ + public void wakeupSelector() { + selector.wakeup(); + } + + /** + * Add FrameBuffer to the list of select interest changes and wake up the + * selector if it's blocked. When the select() call exits, it'll give the + * FrameBuffer a chance to change its interests. + */ + public void requestSelectInterestChange(FrameBuffer frameBuffer) { + synchronized (selectInterestChanges) { + selectInterestChanges.add(frameBuffer); + } + // wakeup the selector, if it's currently blocked. + selector.wakeup(); + } + + /** + * Check to see if there are any FrameBuffers that have switched their + * interest type from read to write or vice versa. + */ + protected void processInterestChanges() { + synchronized (selectInterestChanges) { + for (FrameBuffer fb : selectInterestChanges) { + fb.changeSelectInterests(); + } + selectInterestChanges.clear(); + } + } + + /** + * Do the work required to read from a readable client. If the frame is + * fully read, then invoke the method call. + */ + protected void handleRead(SelectionKey key) { + FrameBuffer buffer = (FrameBuffer) key.attachment(); + if (!buffer.read()) { + cleanupSelectionKey(key); + return; + } + + // if the buffer's frame read is complete, invoke the method. + if (buffer.isFrameFullyRead()) { + if (!requestInvoke(buffer)) { + cleanupSelectionKey(key); + } + } + } + + /** + * Let a writable client get written, if there's data to be written. + */ + protected void handleWrite(SelectionKey key) { + FrameBuffer buffer = (FrameBuffer) key.attachment(); + if (!buffer.write()) { + cleanupSelectionKey(key); + } + } + + /** + * Do connection-close cleanup on a given SelectionKey. + */ + protected void cleanupSelectionKey(SelectionKey key) { + // remove the records from the two maps + FrameBuffer buffer = (FrameBuffer) key.attachment(); + if (buffer != null) { + // close the buffer + buffer.close(); + } + // cancel the selection key + key.cancel(); + } + } // SelectThread + + /** + * Possible states for the FrameBuffer state machine. + */ + private enum FrameBufferState { + // in the midst of reading the frame size off the wire + READING_FRAME_SIZE, + // reading the actual frame data now, but not all the way done yet + READING_FRAME, + // completely read the frame, so an invocation can now happen + READ_FRAME_COMPLETE, + // waiting to get switched to listening for write events + AWAITING_REGISTER_WRITE, + // started writing response data, not fully complete yet + WRITING, + // another thread wants this framebuffer to go back to reading + AWAITING_REGISTER_READ, + // we want our transport and selection key invalidated in the selector + // thread + AWAITING_CLOSE + } + + /** + * Class that implements a sort of state machine around the interaction with a + * client and an invoker. It manages reading the frame size and frame data, + * getting it handed off as wrapped transports, and then the writing of + * response data back to the client. In the process it manages flipping the + * read and write bits on the selection key for its client. + */ + public class FrameBuffer { + private final Logger LOGGER = LoggerFactory.getLogger(getClass().getName()); + + // the actual transport hooked up to the client. + protected final TNonblockingTransport trans_; + + // the SelectionKey that corresponds to our transport + protected final SelectionKey selectionKey_; + + // the SelectThread that owns the registration of our transport + protected final AbstractSelectThread selectThread_; + + // where in the process of reading/writing are we? + protected FrameBufferState state_ = FrameBufferState.READING_FRAME_SIZE; + + // the ByteBuffer we'll be using to write and read, depending on the state + protected ByteBuffer buffer_; + + protected final TByteArrayOutputStream response_; + + // the frame that the TTransport should wrap. + protected final TMemoryInputTransport frameTrans_; + + // the transport that should be used to connect to clients + protected final TTransport inTrans_; + + protected final TTransport outTrans_; + + // the input protocol to use on frames + protected final TProtocol inProt_; + + // the output protocol to use on frames + protected final TProtocol outProt_; + + // context associated with this connection + protected final ServerContext context_; + + public FrameBuffer(final TNonblockingTransport trans, + final SelectionKey selectionKey, + final AbstractSelectThread selectThread) { + trans_ = trans; + selectionKey_ = selectionKey; + selectThread_ = selectThread; + buffer_ = ByteBuffer.allocate(4); + + frameTrans_ = new TMemoryInputTransport(); + response_ = new TByteArrayOutputStream(); + inTrans_ = inputTransportFactory_.getTransport(frameTrans_); + outTrans_ = outputTransportFactory_.getTransport(new TIOStreamTransport(response_)); + inProt_ = inputProtocolFactory_.getProtocol(inTrans_); + outProt_ = outputProtocolFactory_.getProtocol(outTrans_); + + if (eventHandler_ != null) { + context_ = eventHandler_.createContext(inProt_, outProt_); + } else { + context_ = null; + } + } + + /** + * Give this FrameBuffer a chance to read. The selector loop should have + * received a read event for this FrameBuffer. + * + * @return true if the connection should live on, false if it should be + * closed + */ + public boolean read() { + if (state_ == FrameBufferState.READING_FRAME_SIZE) { + // try to read the frame size completely + if (!internalRead()) { + return false; + } + + // if the frame size has been read completely, then prepare to read the + // actual frame. + if (buffer_.remaining() == 0) { + // pull out the frame size as an integer. + int frameSize = buffer_.getInt(0); + if (frameSize <= 0) { + LOGGER.error("Read an invalid frame size of " + frameSize + + ". Are you using TFramedTransport on the client side?"); + return false; + } + + // if this frame will always be too large for this server, log the + // error and close the connection. + if (frameSize > MAX_READ_BUFFER_BYTES) { + LOGGER.error("Read a frame size of " + frameSize + + ", which is bigger than the maximum allowable buffer size for ALL connections."); + return false; + } + + // if this frame will push us over the memory limit, then return. + // with luck, more memory will free up the next time around. + if (readBufferBytesAllocated.get() + frameSize > MAX_READ_BUFFER_BYTES) { + return true; + } + + // increment the amount of memory allocated to read buffers + readBufferBytesAllocated.addAndGet(frameSize + 4); + + // reallocate the readbuffer as a frame-sized buffer + buffer_ = ByteBuffer.allocate(frameSize + 4); + buffer_.putInt(frameSize); + + state_ = FrameBufferState.READING_FRAME; + } else { + // this skips the check of READING_FRAME state below, since we can't + // possibly go on to that state if there's data left to be read at + // this one. + return true; + } + } + + // it is possible to fall through from the READING_FRAME_SIZE section + // to READING_FRAME if there's already some frame data available once + // READING_FRAME_SIZE is complete. + + if (state_ == FrameBufferState.READING_FRAME) { + if (!internalRead()) { + return false; + } + + // since we're already in the select loop here for sure, we can just + // modify our selection key directly. + if (buffer_.remaining() == 0) { + // get rid of the read select interests + selectionKey_.interestOps(0); + state_ = FrameBufferState.READ_FRAME_COMPLETE; + } + + return true; + } + + // if we fall through to this point, then the state must be invalid. + LOGGER.error("Read was called but state is invalid (" + state_ + ")"); + return false; + } + + /** + * Give this FrameBuffer a chance to write its output to the final client. + */ + public boolean write() { + if (state_ == FrameBufferState.WRITING) { + try { + if (trans_.write(buffer_) < 0) { + return false; + } + } catch (IOException e) { + LOGGER.warn("Got an IOException during write!", e); + return false; + } + + // we're done writing. now we need to switch back to reading. + if (buffer_.remaining() == 0) { + prepareRead(); + } + return true; + } + + LOGGER.error("Write was called, but state is invalid (" + state_ + ")"); + return false; + } + + /** + * Give this FrameBuffer a chance to set its interest to write, once data + * has come in. + */ + public void changeSelectInterests() { + if (state_ == FrameBufferState.AWAITING_REGISTER_WRITE) { + // set the OP_WRITE interest + selectionKey_.interestOps(SelectionKey.OP_WRITE); + state_ = FrameBufferState.WRITING; + } else if (state_ == FrameBufferState.AWAITING_REGISTER_READ) { + prepareRead(); + } else if (state_ == FrameBufferState.AWAITING_CLOSE) { + close(); + selectionKey_.cancel(); + } else { + LOGGER.error("changeSelectInterest was called, but state is invalid (" + state_ + ")"); + } + } + + /** + * Shut the connection down. + */ + public void close() { + // if we're being closed due to an error, we might have allocated a + // buffer that we need to subtract for our memory accounting. + if (state_ == FrameBufferState.READING_FRAME || + state_ == FrameBufferState.READ_FRAME_COMPLETE || + state_ == FrameBufferState.AWAITING_CLOSE) { + readBufferBytesAllocated.addAndGet(-buffer_.array().length); + } + trans_.close(); + if (eventHandler_ != null) { + eventHandler_.deleteContext(context_, inProt_, outProt_); + } + } + + /** + * Check if this FrameBuffer has a full frame read. + */ + public boolean isFrameFullyRead() { + return state_ == FrameBufferState.READ_FRAME_COMPLETE; + } + + /** + * After the processor has processed the invocation, whatever thread is + * managing invocations should call this method on this FrameBuffer so we + * know it's time to start trying to write again. Also, if it turns out that + * there actually isn't any data in the response buffer, we'll skip trying + * to write and instead go back to reading. + */ + public void responseReady() { + // the read buffer is definitely no longer in use, so we will decrement + // our read buffer count. we do this here as well as in close because + // we'd like to free this read memory up as quickly as possible for other + // clients. + readBufferBytesAllocated.addAndGet(-buffer_.array().length); + + if (response_.len() == 0) { + // go straight to reading again. this was probably an oneway method + state_ = FrameBufferState.AWAITING_REGISTER_READ; + buffer_ = null; + } else { + buffer_ = ByteBuffer.wrap(response_.get(), 0, response_.len()); + + // set state that we're waiting to be switched to write. we do this + // asynchronously through requestSelectInterestChange() because there is + // a possibility that we're not in the main thread, and thus currently + // blocked in select(). (this functionality is in place for the sake of + // the HsHa server.) + state_ = FrameBufferState.AWAITING_REGISTER_WRITE; + } + requestSelectInterestChange(); + } + + /** + * Actually invoke the method signified by this FrameBuffer. + */ + public void invoke() { + frameTrans_.reset(buffer_.array()); + response_.reset(); + + try { + if (eventHandler_ != null) { + eventHandler_.processContext(context_, inTrans_, outTrans_); + } + processorFactory_.getProcessor(inTrans_).process(inProt_, outProt_); + responseReady(); + return; + } catch (TException te) { + LOGGER.warn("Exception while invoking!", te); + } catch (Throwable t) { + LOGGER.error("Unexpected throwable while invoking!", t); + } + // This will only be reached when there is a throwable. + state_ = FrameBufferState.AWAITING_CLOSE; + requestSelectInterestChange(); + } + + /** + * Perform a read into buffer. + * + * @return true if the read succeeded, false if there was an error or the + * connection closed. + */ + private boolean internalRead() { + try { + if (trans_.read(buffer_) < 0) { + return false; + } + return true; + } catch (IOException e) { + LOGGER.warn("Got an IOException in internalRead!", e); + return false; + } + } + + /** + * We're done writing, so reset our interest ops and change state + * accordingly. + */ + private void prepareRead() { + // we can set our interest directly without using the queue because + // we're in the select thread. + selectionKey_.interestOps(SelectionKey.OP_READ); + // get ready for another go-around + buffer_ = ByteBuffer.allocate(4); + state_ = FrameBufferState.READING_FRAME_SIZE; + } + + /** + * When this FrameBuffer needs to change its select interests and execution + * might not be in its select thread, then this method will make sure the + * interest change gets done when the select thread wakes back up. When the + * current thread is this FrameBuffer's select thread, then it just does the + * interest change immediately. + */ + protected void requestSelectInterestChange() { + if (Thread.currentThread() == this.selectThread_) { + changeSelectInterests(); + } else { + this.selectThread_.requestSelectInterestChange(this); + } + } + } // FrameBuffer + + public class AsyncFrameBuffer extends FrameBuffer { + public AsyncFrameBuffer(TNonblockingTransport trans, SelectionKey selectionKey, AbstractSelectThread selectThread) { + super(trans, selectionKey, selectThread); + } + + public TProtocol getInputProtocol() { + return inProt_; + } + + public TProtocol getOutputProtocol() { + return outProt_; + } + + + public void invoke() { + frameTrans_.reset(buffer_.array()); + response_.reset(); + + try { + if (eventHandler_ != null) { + eventHandler_.processContext(context_, inTrans_, outTrans_); + } + ((TAsyncProcessor)processorFactory_.getProcessor(inTrans_)).process(this); + return; + } catch (TException te) { + LOGGER.warn("Exception while invoking!", te); + } catch (Throwable t) { + LOGGER.error("Unexpected throwable while invoking!", t); + } + // This will only be reached when there is a throwable. + state_ = FrameBufferState.AWAITING_CLOSE; + requestSelectInterestChange(); + } + } +} diff --git a/app/src/main/java/org/apache/thrift/server/Invocation.java b/app/src/main/java/org/apache/thrift/server/Invocation.java new file mode 100644 index 0000000..e8210f4 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/Invocation.java @@ -0,0 +1,20 @@ +package org.apache.thrift.server; + +import org.apache.thrift.server.AbstractNonblockingServer.FrameBuffer; + +/** + * An Invocation represents a method call that is prepared to execute, given + * an idle worker thread. It contains the input and output protocols the + * thread's processor should use to perform the usual Thrift invocation. + */ +class Invocation implements Runnable { + private final FrameBuffer frameBuffer; + + public Invocation(final FrameBuffer frameBuffer) { + this.frameBuffer = frameBuffer; + } + + public void run() { + frameBuffer.invoke(); + } +} \ No newline at end of file diff --git a/app/src/main/java/org/apache/thrift/server/ServerContext.java b/app/src/main/java/org/apache/thrift/server/ServerContext.java new file mode 100644 index 0000000..9b0b99e --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/ServerContext.java @@ -0,0 +1,26 @@ +/* + * 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. + */ + +/** + * Interface for storing server's connection context + */ + +package org.apache.thrift.server; + +public interface ServerContext {} diff --git a/app/src/main/java/org/apache/thrift/server/THsHaServer.java b/app/src/main/java/org/apache/thrift/server/THsHaServer.java new file mode 100644 index 0000000..2ef4b83 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/THsHaServer.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.thrift.server; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import org.apache.thrift.transport.TNonblockingServerTransport; + +/** + * An extension of the TNonblockingServer to a Half-Sync/Half-Async server. + * Like TNonblockingServer, it relies on the use of TFramedTransport. + */ +public class THsHaServer extends TNonblockingServer { + + public static class Args extends AbstractNonblockingServerArgs<Args> { + public int minWorkerThreads = 5; + public int maxWorkerThreads = Integer.MAX_VALUE; + private int stopTimeoutVal = 60; + private TimeUnit stopTimeoutUnit = TimeUnit.SECONDS; + private ExecutorService executorService = null; + + public Args(TNonblockingServerTransport transport) { + super(transport); + } + + public Args minWorkerThreads(int n) { + minWorkerThreads = n; + return this; + } + + public Args maxWorkerThreads(int n) { + maxWorkerThreads = n; + return this; + } + + public int getMinWorkerThreads() { + return minWorkerThreads; + } + + public int getMaxWorkerThreads() { + return maxWorkerThreads; + } + + public int getStopTimeoutVal() { + return stopTimeoutVal; + } + + public Args stopTimeoutVal(int stopTimeoutVal) { + this.stopTimeoutVal = stopTimeoutVal; + return this; + } + + public TimeUnit getStopTimeoutUnit() { + return stopTimeoutUnit; + } + + public Args stopTimeoutUnit(TimeUnit stopTimeoutUnit) { + this.stopTimeoutUnit = stopTimeoutUnit; + return this; + } + + public ExecutorService getExecutorService() { + return executorService; + } + + public Args executorService(ExecutorService executorService) { + this.executorService = executorService; + return this; + } + } + + + // This wraps all the functionality of queueing and thread pool management + // for the passing of Invocations from the Selector to workers. + private final ExecutorService invoker; + + private final Args args; + + /** + * Create the server with the specified Args configuration + */ + public THsHaServer(Args args) { + super(args); + + invoker = args.executorService == null ? createInvokerPool(args) : args.executorService; + this.args = args; + } + + /** + * @inheritDoc + */ + @Override + protected void waitForShutdown() { + joinSelector(); + gracefullyShutdownInvokerPool(); + } + + /** + * Helper to create an invoker pool + */ + protected static ExecutorService createInvokerPool(Args options) { + int minWorkerThreads = options.minWorkerThreads; + int maxWorkerThreads = options.maxWorkerThreads; + int stopTimeoutVal = options.stopTimeoutVal; + TimeUnit stopTimeoutUnit = options.stopTimeoutUnit; + + LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(); + ExecutorService invoker = new ThreadPoolExecutor(minWorkerThreads, + maxWorkerThreads, stopTimeoutVal, stopTimeoutUnit, queue); + + return invoker; + } + + + protected void gracefullyShutdownInvokerPool() { + // try to gracefully shut down the executor service + invoker.shutdown(); + + // Loop until awaitTermination finally does return without a interrupted + // exception. If we don't do this, then we'll shut down prematurely. We want + // to let the executorService clear it's task queue, closing client sockets + // appropriately. + long timeoutMS = args.stopTimeoutUnit.toMillis(args.stopTimeoutVal); + long now = System.currentTimeMillis(); + while (timeoutMS >= 0) { + try { + invoker.awaitTermination(timeoutMS, TimeUnit.MILLISECONDS); + break; + } catch (InterruptedException ix) { + long newnow = System.currentTimeMillis(); + timeoutMS -= (newnow - now); + now = newnow; + } + } + } + + /** + * We override the standard invoke method here to queue the invocation for + * invoker service instead of immediately invoking. The thread pool takes care + * of the rest. + */ + @Override + protected boolean requestInvoke(FrameBuffer frameBuffer) { + try { + Runnable invocation = getRunnable(frameBuffer); + invoker.execute(invocation); + return true; + } catch (RejectedExecutionException rx) { + LOGGER.warn("ExecutorService rejected execution!", rx); + return false; + } + } + + protected Runnable getRunnable(FrameBuffer frameBuffer){ + return new Invocation(frameBuffer); + } +} diff --git a/app/src/main/java/org/apache/thrift/server/TNonblockingServer.java b/app/src/main/java/org/apache/thrift/server/TNonblockingServer.java new file mode 100644 index 0000000..fe0365a --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TNonblockingServer.java @@ -0,0 +1,248 @@ +/* + * 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.thrift.server; + +import org.apache.thrift.transport.TNonblockingServerTransport; +import org.apache.thrift.transport.TNonblockingTransport; +import org.apache.thrift.transport.TTransportException; + +import java.io.IOException; +import java.nio.channels.SelectionKey; +import java.util.Iterator; + +/** + * A nonblocking TServer implementation. This allows for fairness amongst all + * connected clients in terms of invocations. + * + * This server is inherently single-threaded. If you want a limited thread pool + * coupled with invocation-fairness, see THsHaServer. + * + * To use this server, you MUST use a TFramedTransport at the outermost + * transport, otherwise this server will be unable to determine when a whole + * method call has been read off the wire. Clients must also use TFramedTransport. + */ +public class TNonblockingServer extends AbstractNonblockingServer { + + public static class Args extends AbstractNonblockingServerArgs<Args> { + public Args(TNonblockingServerTransport transport) { + super(transport); + } + } + + private SelectAcceptThread selectAcceptThread_; + + public TNonblockingServer(AbstractNonblockingServerArgs args) { + super(args); + } + + + /** + * Start the selector thread to deal with accepts and client messages. + * + * @return true if everything went ok, false if we couldn't start for some + * reason. + */ + @Override + protected boolean startThreads() { + // start the selector + try { + selectAcceptThread_ = new SelectAcceptThread((TNonblockingServerTransport)serverTransport_); + selectAcceptThread_.start(); + return true; + } catch (IOException e) { + LOGGER.error("Failed to start selector thread!", e); + return false; + } + } + + @Override + protected void waitForShutdown() { + joinSelector(); + } + + /** + * Block until the selector thread exits. + */ + protected void joinSelector() { + // wait until the selector thread exits + try { + selectAcceptThread_.join(); + } catch (InterruptedException e) { + // for now, just silently ignore. technically this means we'll have less of + // a graceful shutdown as a result. + } + } + + /** + * Stop serving and shut everything down. + */ + @Override + public void stop() { + stopped_ = true; + if (selectAcceptThread_ != null) { + selectAcceptThread_.wakeupSelector(); + } + } + + /** + * Perform an invocation. This method could behave several different ways + * - invoke immediately inline, queue for separate execution, etc. + */ + @Override + protected boolean requestInvoke(FrameBuffer frameBuffer) { + frameBuffer.invoke(); + return true; + } + + + public boolean isStopped() { + return selectAcceptThread_.isStopped(); + } + + /** + * The thread that will be doing all the selecting, managing new connections + * and those that still need to be read. + */ + protected class SelectAcceptThread extends AbstractSelectThread { + + // The server transport on which new client transports will be accepted + private final TNonblockingServerTransport serverTransport; + + /** + * Set up the thread that will handle the non-blocking accepts, reads, and + * writes. + */ + public SelectAcceptThread(final TNonblockingServerTransport serverTransport) + throws IOException { + this.serverTransport = serverTransport; + serverTransport.registerSelector(selector); + } + + public boolean isStopped() { + return stopped_; + } + + /** + * The work loop. Handles both selecting (all IO operations) and managing + * the selection preferences of all existing connections. + */ + public void run() { + try { + if (eventHandler_ != null) { + eventHandler_.preServe(); + } + + while (!stopped_) { + select(); + processInterestChanges(); + } + for (SelectionKey selectionKey : selector.keys()) { + cleanupSelectionKey(selectionKey); + } + } catch (Throwable t) { + LOGGER.error("run() exiting due to uncaught error", t); + } finally { + try { + selector.close(); + } catch (IOException e) { + LOGGER.error("Got an IOException while closing selector!", e); + } + stopped_ = true; + } + } + + /** + * Select and process IO events appropriately: + * If there are connections to be accepted, accept them. + * If there are existing connections with data waiting to be read, read it, + * buffering until a whole frame has been read. + * If there are any pending responses, buffer them until their target client + * is available, and then send the data. + */ + private void select() { + try { + // wait for io events. + selector.select(); + + // process the io events we received + Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator(); + while (!stopped_ && selectedKeys.hasNext()) { + SelectionKey key = selectedKeys.next(); + selectedKeys.remove(); + + // skip if not valid + if (!key.isValid()) { + cleanupSelectionKey(key); + continue; + } + + // if the key is marked Accept, then it has to be the server + // transport. + if (key.isAcceptable()) { + handleAccept(); + } else if (key.isReadable()) { + // deal with reads + handleRead(key); + } else if (key.isWritable()) { + // deal with writes + handleWrite(key); + } else { + LOGGER.warn("Unexpected state in select! " + key.interestOps()); + } + } + } catch (IOException e) { + LOGGER.warn("Got an IOException while selecting!", e); + } + } + + protected FrameBuffer createFrameBuffer(final TNonblockingTransport trans, + final SelectionKey selectionKey, + final AbstractSelectThread selectThread) { + return processorFactory_.isAsyncProcessor() ? + new AsyncFrameBuffer(trans, selectionKey, selectThread) : + new FrameBuffer(trans, selectionKey, selectThread); + } + + /** + * Accept a new connection. + */ + private void handleAccept() throws IOException { + SelectionKey clientKey = null; + TNonblockingTransport client = null; + try { + // accept the connection + client = (TNonblockingTransport)serverTransport.accept(); + clientKey = client.registerSelector(selector, SelectionKey.OP_READ); + + // add this key to the map + FrameBuffer frameBuffer = createFrameBuffer(client, clientKey, SelectAcceptThread.this); + + clientKey.attach(frameBuffer); + } catch (TTransportException tte) { + // something went wrong accepting. + LOGGER.warn("Exception trying to accept!", tte); + tte.printStackTrace(); + if (clientKey != null) cleanupSelectionKey(clientKey); + if (client != null) client.close(); + } + } + } // SelectAcceptThread +} diff --git a/app/src/main/java/org/apache/thrift/server/TServer.java b/app/src/main/java/org/apache/thrift/server/TServer.java new file mode 100644 index 0000000..80f4f86 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TServer.java @@ -0,0 +1,177 @@ +/* + * 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.thrift.server; + +import org.apache.thrift.TProcessor; +import org.apache.thrift.TProcessorFactory; +import org.apache.thrift.protocol.TBinaryProtocol; +import org.apache.thrift.protocol.TProtocolFactory; +import org.apache.thrift.transport.TServerTransport; +import org.apache.thrift.transport.TTransportFactory; + +/** + * Generic interface for a Thrift server. + * + */ +public abstract class TServer { + + public static class Args extends AbstractServerArgs<Args> { + public Args(TServerTransport transport) { + super(transport); + } + } + + public static abstract class AbstractServerArgs<T extends AbstractServerArgs<T>> { + final TServerTransport serverTransport; + TProcessorFactory processorFactory; + TTransportFactory inputTransportFactory = new TTransportFactory(); + TTransportFactory outputTransportFactory = new TTransportFactory(); + TProtocolFactory inputProtocolFactory = new TBinaryProtocol.Factory(); + TProtocolFactory outputProtocolFactory = new TBinaryProtocol.Factory(); + + public AbstractServerArgs(TServerTransport transport) { + serverTransport = transport; + } + + public T processorFactory(TProcessorFactory factory) { + this.processorFactory = factory; + return (T) this; + } + + public T processor(TProcessor processor) { + this.processorFactory = new TProcessorFactory(processor); + return (T) this; + } + + public T transportFactory(TTransportFactory factory) { + this.inputTransportFactory = factory; + this.outputTransportFactory = factory; + return (T) this; + } + + public T inputTransportFactory(TTransportFactory factory) { + this.inputTransportFactory = factory; + return (T) this; + } + + public T outputTransportFactory(TTransportFactory factory) { + this.outputTransportFactory = factory; + return (T) this; + } + + public T protocolFactory(TProtocolFactory factory) { + this.inputProtocolFactory = factory; + this.outputProtocolFactory = factory; + return (T) this; + } + + public T inputProtocolFactory(TProtocolFactory factory) { + this.inputProtocolFactory = factory; + return (T) this; + } + + public T outputProtocolFactory(TProtocolFactory factory) { + this.outputProtocolFactory = factory; + return (T) this; + } + } + + /** + * Core processor + */ + protected TProcessorFactory processorFactory_; + + /** + * Server transport + */ + protected TServerTransport serverTransport_; + + /** + * Input Transport Factory + */ + protected TTransportFactory inputTransportFactory_; + + /** + * Output Transport Factory + */ + protected TTransportFactory outputTransportFactory_; + + /** + * Input Protocol Factory + */ + protected TProtocolFactory inputProtocolFactory_; + + /** + * Output Protocol Factory + */ + protected TProtocolFactory outputProtocolFactory_; + + private boolean isServing; + + protected TServerEventHandler eventHandler_; + + // Flag for stopping the server + // Please see THRIFT-1795 for the usage of this flag + protected volatile boolean stopped_ = false; + + protected TServer(AbstractServerArgs args) { + processorFactory_ = args.processorFactory; + serverTransport_ = args.serverTransport; + inputTransportFactory_ = args.inputTransportFactory; + outputTransportFactory_ = args.outputTransportFactory; + inputProtocolFactory_ = args.inputProtocolFactory; + outputProtocolFactory_ = args.outputProtocolFactory; + } + + /** + * The run method fires up the server and gets things going. + */ + public abstract void serve(); + + /** + * Stop the server. This is optional on a per-implementation basis. Not + * all servers are required to be cleanly stoppable. + */ + public void stop() {} + + public boolean isServing() { + return isServing; + } + + protected void setServing(boolean serving) { + isServing = serving; + } + + public void setServerEventHandler(TServerEventHandler eventHandler) { + eventHandler_ = eventHandler; + } + + public TServerEventHandler getEventHandler() { + return eventHandler_; + } + + public boolean getShouldStop() { + return this.stopped_; + } + + public void setShouldStop(boolean shouldStop) { + this.stopped_ = shouldStop; + } +} diff --git a/app/src/main/java/org/apache/thrift/server/TServerEventHandler.java b/app/src/main/java/org/apache/thrift/server/TServerEventHandler.java new file mode 100644 index 0000000..f069b9b --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TServerEventHandler.java @@ -0,0 +1,59 @@ +/* + * 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.thrift.server; + +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.transport.TTransport; + +/** + * Interface that can handle events from the server core. To + * use this you should subclass it and implement the methods that you care + * about. Your subclass can also store local data that you may care about, + * such as additional "arguments" to these methods (stored in the object + * instance's state). + */ +public interface TServerEventHandler { + + /** + * Called before the server begins. + */ + void preServe(); + + /** + * Called when a new client has connected and is about to being processing. + */ + ServerContext createContext(TProtocol input, + TProtocol output); + + /** + * Called when a client has finished request-handling to delete server + * context. + */ + void deleteContext(ServerContext serverContext, + TProtocol input, + TProtocol output); + + /** + * Called when a client is about to call the processor. + */ + void processContext(ServerContext serverContext, + TTransport inputTransport, TTransport outputTransport); + +} \ No newline at end of file diff --git a/app/src/main/java/org/apache/thrift/server/TSimpleServer.java b/app/src/main/java/org/apache/thrift/server/TSimpleServer.java new file mode 100644 index 0000000..e815b2c --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TSimpleServer.java @@ -0,0 +1,117 @@ +/* + * 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.thrift.server; + +import org.apache.thrift.TException; +import org.apache.thrift.TProcessor; +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.transport.TTransport; +import org.apache.thrift.transport.TTransportException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Simple singlethreaded server for testing. + * + */ +public class TSimpleServer extends TServer { + + private static final Logger LOGGER = LoggerFactory.getLogger(TSimpleServer.class.getName()); + + public TSimpleServer(AbstractServerArgs args) { + super(args); + } + + public void serve() { + try { + serverTransport_.listen(); + } catch (TTransportException ttx) { + LOGGER.error("Error occurred during listening.", ttx); + return; + } + + // Run the preServe event + if (eventHandler_ != null) { + eventHandler_.preServe(); + } + + setServing(true); + + while (!stopped_) { + TTransport client = null; + TProcessor processor = null; + TTransport inputTransport = null; + TTransport outputTransport = null; + TProtocol inputProtocol = null; + TProtocol outputProtocol = null; + ServerContext connectionContext = null; + try { + client = serverTransport_.accept(); + if (client != null) { + processor = processorFactory_.getProcessor(client); + inputTransport = inputTransportFactory_.getTransport(client); + outputTransport = outputTransportFactory_.getTransport(client); + inputProtocol = inputProtocolFactory_.getProtocol(inputTransport); + outputProtocol = outputProtocolFactory_.getProtocol(outputTransport); + if (eventHandler_ != null) { + connectionContext = eventHandler_.createContext(inputProtocol, outputProtocol); + } + while (true) { + if (eventHandler_ != null) { + eventHandler_.processContext(connectionContext, inputTransport, outputTransport); + } + if(!processor.process(inputProtocol, outputProtocol)) { + break; + } + } + } + } catch (TTransportException ttx) { + // Client died, just move on + } catch (TException tx) { + if (!stopped_) { + LOGGER.error("Thrift error occurred during processing of message.", tx); + } + } catch (Exception x) { + if (!stopped_) { + LOGGER.error("Error occurred during processing of message.", x); + } + } + + if (eventHandler_ != null) { + eventHandler_.deleteContext(connectionContext, inputProtocol, outputProtocol); + } + + if (inputTransport != null) { + inputTransport.close(); + } + + if (outputTransport != null) { + outputTransport.close(); + } + + } + setServing(false); + } + + public void stop() { + stopped_ = true; + serverTransport_.interrupt(); + } +} diff --git a/app/src/main/java/org/apache/thrift/server/TThreadPoolServer.java b/app/src/main/java/org/apache/thrift/server/TThreadPoolServer.java new file mode 100644 index 0000000..6ca5fed --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TThreadPoolServer.java @@ -0,0 +1,311 @@ +/* + * 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.thrift.server; + +import java.util.Random; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.SynchronousQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; + +import org.apache.thrift.TException; +import org.apache.thrift.TProcessor; +import org.apache.thrift.protocol.TProtocol; +import org.apache.thrift.transport.TServerTransport; +import org.apache.thrift.transport.TTransport; +import org.apache.thrift.transport.TTransportException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +/** + * Server which uses Java's built in ThreadPool management to spawn off + * a worker pool that + * + */ +public class TThreadPoolServer extends TServer { + private static final Logger LOGGER = LoggerFactory.getLogger(TThreadPoolServer.class.getName()); + + public static class Args extends AbstractServerArgs<Args> { + public int minWorkerThreads = 5; + public int maxWorkerThreads = Integer.MAX_VALUE; + public ExecutorService executorService; + public int stopTimeoutVal = 60; + public TimeUnit stopTimeoutUnit = TimeUnit.SECONDS; + public int requestTimeout = 20; + public TimeUnit requestTimeoutUnit = TimeUnit.SECONDS; + public int beBackoffSlotLength = 100; + public TimeUnit beBackoffSlotLengthUnit = TimeUnit.MILLISECONDS; + + public Args(TServerTransport transport) { + super(transport); + } + + public Args minWorkerThreads(int n) { + minWorkerThreads = n; + return this; + } + + public Args maxWorkerThreads(int n) { + maxWorkerThreads = n; + return this; + } + + public Args stopTimeoutVal(int n) { + stopTimeoutVal = n; + return this; + } + + public Args requestTimeout(int n) { + requestTimeout = n; + return this; + } + + public Args requestTimeoutUnit(TimeUnit tu) { + requestTimeoutUnit = tu; + return this; + } + //Binary exponential backoff slot length + public Args beBackoffSlotLength(int n) { + beBackoffSlotLength = n; + return this; + } + + //Binary exponential backoff slot time unit + public Args beBackoffSlotLengthUnit(TimeUnit tu) { + beBackoffSlotLengthUnit = tu; + return this; + } + + public Args executorService(ExecutorService executorService) { + this.executorService = executorService; + return this; + } + } + + // Executor service for handling client connections + private ExecutorService executorService_; + + private final TimeUnit stopTimeoutUnit; + + private final long stopTimeoutVal; + + private final TimeUnit requestTimeoutUnit; + + private final long requestTimeout; + + private final long beBackoffSlotInMillis; + + private Random random = new Random(System.currentTimeMillis()); + + public TThreadPoolServer(Args args) { + super(args); + + stopTimeoutUnit = args.stopTimeoutUnit; + stopTimeoutVal = args.stopTimeoutVal; + requestTimeoutUnit = args.requestTimeoutUnit; + requestTimeout = args.requestTimeout; + beBackoffSlotInMillis = args.beBackoffSlotLengthUnit.toMillis(args.beBackoffSlotLength); + + executorService_ = args.executorService != null ? + args.executorService : createDefaultExecutorService(args); + } + + private static ExecutorService createDefaultExecutorService(Args args) { + SynchronousQueue<Runnable> executorQueue = + new SynchronousQueue<Runnable>(); + return new ThreadPoolExecutor(args.minWorkerThreads, + args.maxWorkerThreads, + args.stopTimeoutVal, + TimeUnit.SECONDS, + executorQueue); + } + + + public void serve() { + try { + serverTransport_.listen(); + } catch (TTransportException ttx) { + LOGGER.error("Error occurred during listening.", ttx); + return; + } + + // Run the preServe event + if (eventHandler_ != null) { + eventHandler_.preServe(); + } + + stopped_ = false; + setServing(true); + int failureCount = 0; + while (!stopped_) { + try { + TTransport client = serverTransport_.accept(); + WorkerProcess wp = new WorkerProcess(client); + + int retryCount = 0; + long remainTimeInMillis = requestTimeoutUnit.toMillis(requestTimeout); + while(true) { + try { + executorService_.execute(wp); + break; + } catch(Throwable t) { + if (t instanceof RejectedExecutionException) { + retryCount++; + try { + if (remainTimeInMillis > 0) { + //do a truncated 20 binary exponential backoff sleep + long sleepTimeInMillis = ((long) (random.nextDouble() * + (1L << Math.min(retryCount, 20)))) * beBackoffSlotInMillis; + sleepTimeInMillis = Math.min(sleepTimeInMillis, remainTimeInMillis); + TimeUnit.MILLISECONDS.sleep(sleepTimeInMillis); + remainTimeInMillis = remainTimeInMillis - sleepTimeInMillis; + } else { + client.close(); + wp = null; + LOGGER.warn("Task has been rejected by ExecutorService " + retryCount + + " times till timedout, reason: " + t); + break; + } + } catch (InterruptedException e) { + LOGGER.warn("Interrupted while waiting to place client on executor queue."); + Thread.currentThread().interrupt(); + break; + } + } else if (t instanceof Error) { + LOGGER.error("ExecutorService threw error: " + t, t); + throw (Error)t; + } else { + //for other possible runtime errors from ExecutorService, should also not kill serve + LOGGER.warn("ExecutorService threw error: " + t, t); + break; + } + } + } + } catch (TTransportException ttx) { + if (!stopped_) { + ++failureCount; + LOGGER.warn("Transport error occurred during acceptance of message.", ttx); + } + } + } + + executorService_.shutdown(); + + // Loop until awaitTermination finally does return without a interrupted + // exception. If we don't do this, then we'll shut down prematurely. We want + // to let the executorService clear it's task queue, closing client sockets + // appropriately. + long timeoutMS = stopTimeoutUnit.toMillis(stopTimeoutVal); + long now = System.currentTimeMillis(); + while (timeoutMS >= 0) { + try { + executorService_.awaitTermination(timeoutMS, TimeUnit.MILLISECONDS); + break; + } catch (InterruptedException ix) { + long newnow = System.currentTimeMillis(); + timeoutMS -= (newnow - now); + now = newnow; + } + } + setServing(false); + } + + public void stop() { + stopped_ = true; + serverTransport_.interrupt(); + } + + private class WorkerProcess implements Runnable { + + /** + * Client that this services. + */ + private TTransport client_; + + /** + * Default constructor. + * + * @param client Transport to process + */ + private WorkerProcess(TTransport client) { + client_ = client; + } + + /** + * Loops on processing a client forever + */ + public void run() { + TProcessor processor = null; + TTransport inputTransport = null; + TTransport outputTransport = null; + TProtocol inputProtocol = null; + TProtocol outputProtocol = null; + + TServerEventHandler eventHandler = null; + ServerContext connectionContext = null; + + try { + processor = processorFactory_.getProcessor(client_); + inputTransport = inputTransportFactory_.getTransport(client_); + outputTransport = outputTransportFactory_.getTransport(client_); + inputProtocol = inputProtocolFactory_.getProtocol(inputTransport); + outputProtocol = outputProtocolFactory_.getProtocol(outputTransport); + + eventHandler = getEventHandler(); + if (eventHandler != null) { + connectionContext = eventHandler.createContext(inputProtocol, outputProtocol); + } + // we check stopped_ first to make sure we're not supposed to be shutting + // down. this is necessary for graceful shutdown. + while (true) { + + if (eventHandler != null) { + eventHandler.processContext(connectionContext, inputTransport, outputTransport); + } + + if(stopped_ || !processor.process(inputProtocol, outputProtocol)) { + break; + } + } + } catch (TTransportException ttx) { + // Assume the client died and continue silently + } catch (TException tx) { + LOGGER.error("Thrift error occurred during processing of message.", tx); + } catch (Exception x) { + LOGGER.error("Error occurred during processing of message.", x); + } finally { + if (eventHandler != null) { + eventHandler.deleteContext(connectionContext, inputProtocol, outputProtocol); + } + if (inputTransport != null) { + inputTransport.close(); + } + if (outputTransport != null) { + outputTransport.close(); + } + if (client_.isOpen()) { + client_.close(); + } + } + } + } +} diff --git a/app/src/main/java/org/apache/thrift/server/TThreadedSelectorServer.java b/app/src/main/java/org/apache/thrift/server/TThreadedSelectorServer.java new file mode 100644 index 0000000..353b8e0 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/server/TThreadedSelectorServer.java @@ -0,0 +1,668 @@ +/* + * 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.thrift.server; + +import java.io.IOException; +import java.nio.channels.SelectionKey; +import java.nio.channels.Selector; +import java.nio.channels.spi.SelectorProvider; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.TimeUnit; + +import org.apache.thrift.transport.TNonblockingServerTransport; +import org.apache.thrift.transport.TNonblockingTransport; +import org.apache.thrift.transport.TTransportException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * A Half-Sync/Half-Async server with a separate pool of threads to handle + * non-blocking I/O. Accepts are handled on a single thread, and a configurable + * number of nonblocking selector threads manage reading and writing of client + * connections. A synchronous worker thread pool handles processing of requests. + * + * Performs better than TNonblockingServer/THsHaServer in multi-core + * environments when the the bottleneck is CPU on the single selector thread + * handling I/O. In addition, because the accept handling is decoupled from + * reads/writes and invocation, the server has better ability to handle back- + * pressure from new connections (e.g. stop accepting when busy). + * + * Like TNonblockingServer, it relies on the use of TFramedTransport. + */ +public class TThreadedSelectorServer extends AbstractNonblockingServer { + private static final Logger LOGGER = LoggerFactory.getLogger(TThreadedSelectorServer.class.getName()); + + public static class Args extends AbstractNonblockingServerArgs<Args> { + + /** The number of threads for selecting on already-accepted connections */ + public int selectorThreads = 2; + /** + * The size of the executor service (if none is specified) that will handle + * invocations. This may be set to 0, in which case invocations will be + * handled directly on the selector threads (as is in TNonblockingServer) + */ + private int workerThreads = 5; + /** Time to wait for server to stop gracefully */ + private int stopTimeoutVal = 60; + private TimeUnit stopTimeoutUnit = TimeUnit.SECONDS; + /** The ExecutorService for handling dispatched requests */ + private ExecutorService executorService = null; + /** + * The size of the blocking queue per selector thread for passing accepted + * connections to the selector thread + */ + private int acceptQueueSizePerThread = 4; + + /** + * Determines the strategy for handling new accepted connections. + */ + public static enum AcceptPolicy { + /** + * Require accepted connection registration to be handled by the executor. + * If the worker pool is saturated, further accepts will be closed + * immediately. Slightly increases latency due to an extra scheduling. + */ + FAIR_ACCEPT, + /** + * Handle the accepts as fast as possible, disregarding the status of the + * executor service. + */ + FAST_ACCEPT + } + + private AcceptPolicy acceptPolicy = AcceptPolicy.FAST_ACCEPT; + + public Args(TNonblockingServerTransport transport) { + super(transport); + } + + public Args selectorThreads(int i) { + selectorThreads = i; + return this; + } + + public int getSelectorThreads() { + return selectorThreads; + } + + public Args workerThreads(int i) { + workerThreads = i; + return this; + } + + public int getWorkerThreads() { + return workerThreads; + } + + public int getStopTimeoutVal() { + return stopTimeoutVal; + } + + public Args stopTimeoutVal(int stopTimeoutVal) { + this.stopTimeoutVal = stopTimeoutVal; + return this; + } + + public TimeUnit getStopTimeoutUnit() { + return stopTimeoutUnit; + } + + public Args stopTimeoutUnit(TimeUnit stopTimeoutUnit) { + this.stopTimeoutUnit = stopTimeoutUnit; + return this; + } + + public ExecutorService getExecutorService() { + return executorService; + } + + public Args executorService(ExecutorService executorService) { + this.executorService = executorService; + return this; + } + + public int getAcceptQueueSizePerThread() { + return acceptQueueSizePerThread; + } + + public Args acceptQueueSizePerThread(int acceptQueueSizePerThread) { + this.acceptQueueSizePerThread = acceptQueueSizePerThread; + return this; + } + + public AcceptPolicy getAcceptPolicy() { + return acceptPolicy; + } + + public Args acceptPolicy(AcceptPolicy acceptPolicy) { + this.acceptPolicy = acceptPolicy; + return this; + } + + public void validate() { + if (selectorThreads <= 0) { + throw new IllegalArgumentException("selectorThreads must be positive."); + } + if (workerThreads < 0) { + throw new IllegalArgumentException("workerThreads must be non-negative."); + } + if (acceptQueueSizePerThread <= 0) { + throw new IllegalArgumentException("acceptQueueSizePerThread must be positive."); + } + } + } + + // The thread handling all accepts + private AcceptThread acceptThread; + + // Threads handling events on client transports + private final Set<SelectorThread> selectorThreads = new HashSet<SelectorThread>(); + + // This wraps all the functionality of queueing and thread pool management + // for the passing of Invocations from the selector thread(s) to the workers + // (if any). + private final ExecutorService invoker; + + private final Args args; + + /** + * Create the server with the specified Args configuration + */ + public TThreadedSelectorServer(Args args) { + super(args); + args.validate(); + invoker = args.executorService == null ? createDefaultExecutor(args) : args.executorService; + this.args = args; + } + + /** + * Start the accept and selector threads running to deal with clients. + * + * @return true if everything went ok, false if we couldn't start for some + * reason. + */ + @Override + protected boolean startThreads() { + try { + for (int i = 0; i < args.selectorThreads; ++i) { + selectorThreads.add(new SelectorThread(args.acceptQueueSizePerThread)); + } + acceptThread = new AcceptThread((TNonblockingServerTransport) serverTransport_, + createSelectorThreadLoadBalancer(selectorThreads)); + for (SelectorThread thread : selectorThreads) { + thread.start(); + } + acceptThread.start(); + return true; + } catch (IOException e) { + LOGGER.error("Failed to start threads!", e); + return false; + } + } + + /** + * Joins the accept and selector threads and shuts down the executor service. + */ + @Override + protected void waitForShutdown() { + try { + joinThreads(); + } catch (InterruptedException e) { + // Non-graceful shutdown occurred + LOGGER.error("Interrupted while joining threads!", e); + } + gracefullyShutdownInvokerPool(); + } + + protected void joinThreads() throws InterruptedException { + // wait until the io threads exit + acceptThread.join(); + for (SelectorThread thread : selectorThreads) { + thread.join(); + } + } + + /** + * Stop serving and shut everything down. + */ + @Override + public void stop() { + stopped_ = true; + + // Stop queuing connect attempts asap + stopListening(); + + if (acceptThread != null) { + acceptThread.wakeupSelector(); + } + if (selectorThreads != null) { + for (SelectorThread thread : selectorThreads) { + if (thread != null) + thread.wakeupSelector(); + } + } + } + + protected void gracefullyShutdownInvokerPool() { + // try to gracefully shut down the executor service + invoker.shutdown(); + + // Loop until awaitTermination finally does return without a interrupted + // exception. If we don't do this, then we'll shut down prematurely. We want + // to let the executorService clear it's task queue, closing client sockets + // appropriately. + long timeoutMS = args.stopTimeoutUnit.toMillis(args.stopTimeoutVal); + long now = System.currentTimeMillis(); + while (timeoutMS >= 0) { + try { + invoker.awaitTermination(timeoutMS, TimeUnit.MILLISECONDS); + break; + } catch (InterruptedException ix) { + long newnow = System.currentTimeMillis(); + timeoutMS -= (newnow - now); + now = newnow; + } + } + } + + /** + * We override the standard invoke method here to queue the invocation for + * invoker service instead of immediately invoking. If there is no thread + * pool, handle the invocation inline on this thread + */ + @Override + protected boolean requestInvoke(FrameBuffer frameBuffer) { + Runnable invocation = getRunnable(frameBuffer); + if (invoker != null) { + try { + invoker.execute(invocation); + return true; + } catch (RejectedExecutionException rx) { + LOGGER.warn("ExecutorService rejected execution!", rx); + return false; + } + } else { + // Invoke on the caller's thread + invocation.run(); + return true; + } + } + + protected Runnable getRunnable(FrameBuffer frameBuffer) { + return new Invocation(frameBuffer); + } + + /** + * Helper to create the invoker if one is not specified + */ + protected static ExecutorService createDefaultExecutor(Args options) { + return (options.workerThreads > 0) ? Executors.newFixedThreadPool(options.workerThreads) : null; + } + + private static BlockingQueue<TNonblockingTransport> createDefaultAcceptQueue(int queueSize) { + if (queueSize == 0) { + // Unbounded queue + return new LinkedBlockingQueue<TNonblockingTransport>(); + } + return new ArrayBlockingQueue<TNonblockingTransport>(queueSize); + } + + /** + * The thread that selects on the server transport (listen socket) and accepts + * new connections to hand off to the IO selector threads + */ + protected class AcceptThread extends Thread { + + // The listen socket to accept on + private final TNonblockingServerTransport serverTransport; + private final Selector acceptSelector; + + private final SelectorThreadLoadBalancer threadChooser; + + /** + * Set up the AcceptThead + * + * @throws IOException + */ + public AcceptThread(TNonblockingServerTransport serverTransport, + SelectorThreadLoadBalancer threadChooser) throws IOException { + this.serverTransport = serverTransport; + this.threadChooser = threadChooser; + this.acceptSelector = SelectorProvider.provider().openSelector(); + this.serverTransport.registerSelector(acceptSelector); + } + + /** + * The work loop. Selects on the server transport and accepts. If there was + * a server transport that had blocking accepts, and returned on blocking + * client transports, that should be used instead + */ + public void run() { + try { + if (eventHandler_ != null) { + eventHandler_.preServe(); + } + + while (!stopped_) { + select(); + } + } catch (Throwable t) { + LOGGER.error("run() on AcceptThread exiting due to uncaught error", t); + } finally { + try { + acceptSelector.close(); + } catch (IOException e) { + LOGGER.error("Got an IOException while closing accept selector!", e); + } + // This will wake up the selector threads + TThreadedSelectorServer.this.stop(); + } + } + + /** + * If the selector is blocked, wake it up. + */ + public void wakeupSelector() { + acceptSelector.wakeup(); + } + + /** + * Select and process IO events appropriately: If there are connections to + * be accepted, accept them. + */ + private void select() { + try { + // wait for connect events. + acceptSelector.select(); + + // process the io events we received + Iterator<SelectionKey> selectedKeys = acceptSelector.selectedKeys().iterator(); + while (!stopped_ && selectedKeys.hasNext()) { + SelectionKey key = selectedKeys.next(); + selectedKeys.remove(); + + // skip if not valid + if (!key.isValid()) { + continue; + } + + if (key.isAcceptable()) { + handleAccept(); + } else { + LOGGER.warn("Unexpected state in select! " + key.interestOps()); + } + } + } catch (IOException e) { + LOGGER.warn("Got an IOException while selecting!", e); + } + } + + /** + * Accept a new connection. + */ + private void handleAccept() { + final TNonblockingTransport client = doAccept(); + if (client != null) { + // Pass this connection to a selector thread + final SelectorThread targetThread = threadChooser.nextThread(); + + if (args.acceptPolicy == Args.AcceptPolicy.FAST_ACCEPT || invoker == null) { + doAddAccept(targetThread, client); + } else { + // FAIR_ACCEPT + try { + invoker.submit(new Runnable() { + public void run() { + doAddAccept(targetThread, client); + } + }); + } catch (RejectedExecutionException rx) { + LOGGER.warn("ExecutorService rejected accept registration!", rx); + // close immediately + client.close(); + } + } + } + } + + private TNonblockingTransport doAccept() { + try { + return (TNonblockingTransport) serverTransport.accept(); + } catch (TTransportException tte) { + // something went wrong accepting. + LOGGER.warn("Exception trying to accept!", tte); + return null; + } + } + + private void doAddAccept(SelectorThread thread, TNonblockingTransport client) { + if (!thread.addAcceptedConnection(client)) { + client.close(); + } + } + } // AcceptThread + + /** + * The SelectorThread(s) will be doing all the selecting on accepted active + * connections. + */ + protected class SelectorThread extends AbstractSelectThread { + + // Accepted connections added by the accept thread. + private final BlockingQueue<TNonblockingTransport> acceptedQueue; + + /** + * Set up the SelectorThread with an unbounded queue for incoming accepts. + * + * @throws IOException + * if a selector cannot be created + */ + public SelectorThread() throws IOException { + this(new LinkedBlockingQueue<TNonblockingTransport>()); + } + + /** + * Set up the SelectorThread with an bounded queue for incoming accepts. + * + * @throws IOException + * if a selector cannot be created + */ + public SelectorThread(int maxPendingAccepts) throws IOException { + this(createDefaultAcceptQueue(maxPendingAccepts)); + } + + /** + * Set up the SelectorThread with a specified queue for connections. + * + * @param acceptedQueue + * The BlockingQueue implementation for holding incoming accepted + * connections. + * @throws IOException + * if a selector cannot be created. + */ + public SelectorThread(BlockingQueue<TNonblockingTransport> acceptedQueue) throws IOException { + this.acceptedQueue = acceptedQueue; + } + + /** + * Hands off an accepted connection to be handled by this thread. This + * method will block if the queue for new connections is at capacity. + * + * @param accepted + * The connection that has been accepted. + * @return true if the connection has been successfully added. + */ + public boolean addAcceptedConnection(TNonblockingTransport accepted) { + try { + acceptedQueue.put(accepted); + } catch (InterruptedException e) { + LOGGER.warn("Interrupted while adding accepted connection!", e); + return false; + } + selector.wakeup(); + return true; + } + + /** + * The work loop. Handles selecting (read/write IO), dispatching, and + * managing the selection preferences of all existing connections. + */ + public void run() { + try { + while (!stopped_) { + select(); + processAcceptedConnections(); + processInterestChanges(); + } + for (SelectionKey selectionKey : selector.keys()) { + cleanupSelectionKey(selectionKey); + } + } catch (Throwable t) { + LOGGER.error("run() on SelectorThread exiting due to uncaught error", t); + } finally { + try { + selector.close(); + } catch (IOException e) { + LOGGER.error("Got an IOException while closing selector!", e); + } + // This will wake up the accept thread and the other selector threads + TThreadedSelectorServer.this.stop(); + } + } + + /** + * Select and process IO events appropriately: If there are existing + * connections with data waiting to be read, read it, buffering until a + * whole frame has been read. If there are any pending responses, buffer + * them until their target client is available, and then send the data. + */ + private void select() { + try { + // wait for io events. + selector.select(); + + // process the io events we received + Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator(); + while (!stopped_ && selectedKeys.hasNext()) { + SelectionKey key = selectedKeys.next(); + selectedKeys.remove(); + + // skip if not valid + if (!key.isValid()) { + cleanupSelectionKey(key); + continue; + } + + if (key.isReadable()) { + // deal with reads + handleRead(key); + } else if (key.isWritable()) { + // deal with writes + handleWrite(key); + } else { + LOGGER.warn("Unexpected state in select! " + key.interestOps()); + } + } + } catch (IOException e) { + LOGGER.warn("Got an IOException while selecting!", e); + } + } + + private void processAcceptedConnections() { + // Register accepted connections + while (!stopped_) { + TNonblockingTransport accepted = acceptedQueue.poll(); + if (accepted == null) { + break; + } + registerAccepted(accepted); + } + } + + protected FrameBuffer createFrameBuffer(final TNonblockingTransport trans, + final SelectionKey selectionKey, + final AbstractSelectThread selectThread) { + return processorFactory_.isAsyncProcessor() ? + new AsyncFrameBuffer(trans, selectionKey, selectThread) : + new FrameBuffer(trans, selectionKey, selectThread); + } + + private void registerAccepted(TNonblockingTransport accepted) { + SelectionKey clientKey = null; + try { + clientKey = accepted.registerSelector(selector, SelectionKey.OP_READ); + + FrameBuffer frameBuffer = createFrameBuffer(accepted, clientKey, SelectorThread.this); + + clientKey.attach(frameBuffer); + } catch (IOException e) { + LOGGER.warn("Failed to register accepted connection to selector!", e); + if (clientKey != null) { + cleanupSelectionKey(clientKey); + } + accepted.close(); + } + } + } // SelectorThread + + /** + * Creates a SelectorThreadLoadBalancer to be used by the accept thread for + * assigning newly accepted connections across the threads. + */ + protected SelectorThreadLoadBalancer createSelectorThreadLoadBalancer(Collection<? extends SelectorThread> threads) { + return new SelectorThreadLoadBalancer(threads); + } + + /** + * A round robin load balancer for choosing selector threads for new + * connections. + */ + protected static class SelectorThreadLoadBalancer { + private final Collection<? extends SelectorThread> threads; + private Iterator<? extends SelectorThread> nextThreadIterator; + + public <T extends SelectorThread> SelectorThreadLoadBalancer(Collection<T> threads) { + if (threads.isEmpty()) { + throw new IllegalArgumentException("At least one selector thread is required"); + } + this.threads = Collections.unmodifiableList(new ArrayList<T>(threads)); + nextThreadIterator = this.threads.iterator(); + } + + public SelectorThread nextThread() { + // Choose a selector thread (round robin) + if (!nextThreadIterator.hasNext()) { + nextThreadIterator = threads.iterator(); + } + return nextThreadIterator.next(); + } + } +} diff --git a/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferReadTransport.java b/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferReadTransport.java index d29d60b..081bc48 100644 --- a/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferReadTransport.java +++ b/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferReadTransport.java @@ -18,8 +18,6 @@ */ package org.apache.thrift.transport; -import org.apache.commons.lang.NotImplementedException; - /** * TTransport for reading from an AutoExpandingBuffer. */ @@ -60,7 +58,7 @@ public final int read(byte[] target, int off, int len) throws TTransportExceptio @Override public void write(byte[] buf, int off, int len) throws TTransportException { - throw new NotImplementedException(); + throw new UnsupportedOperationException(); } @Override diff --git a/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferWriteTransport.java b/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferWriteTransport.java index 2376cf3..9b35693 100644 --- a/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferWriteTransport.java +++ b/app/src/main/java/org/apache/thrift/transport/AutoExpandingBufferWriteTransport.java @@ -18,8 +18,6 @@ */ package org.apache.thrift.transport; -import org.apache.commons.lang.NotImplementedException; - /** * TTransport for writing to an AutoExpandingBuffer. */ @@ -44,7 +42,7 @@ public void open() throws TTransportException {} @Override public int read(byte[] buf, int off, int len) throws TTransportException { - throw new NotImplementedException(); + throw new UnsupportedOperationException(); } @Override diff --git a/app/src/main/java/org/apache/thrift/transport/TFileProcessor.java b/app/src/main/java/org/apache/thrift/transport/TFileProcessor.java index 19db896..4e6a198 100644 --- a/app/src/main/java/org/apache/thrift/transport/TFileProcessor.java +++ b/app/src/main/java/org/apache/thrift/transport/TFileProcessor.java @@ -24,16 +24,6 @@ import org.apache.thrift.protocol.TProtocol; import org.apache.thrift.protocol.TProtocolFactory; - -import java.io.FileInputStream; -import java.io.FileOutputStream; -import java.io.RandomAccessFile; -import java.io.BufferedInputStream; -import java.io.BufferedOutputStream; -import java.io.InputStream; -import java.io.OutputStream; -import java.io.IOException; - /** * FileProcessor: helps in processing files generated by TFileTransport. * Port of original cpp implementation diff --git a/app/src/main/java/org/apache/thrift/transport/TFileTransport.java b/app/src/main/java/org/apache/thrift/transport/TFileTransport.java index f5abe53..0044d2a 100644 --- a/app/src/main/java/org/apache/thrift/transport/TFileTransport.java +++ b/app/src/main/java/org/apache/thrift/transport/TFileTransport.java @@ -38,14 +38,14 @@ */ public class TFileTransport extends TTransport { - public static class truncableBufferedInputStream extends BufferedInputStream { + public static class TruncableBufferedInputStream extends BufferedInputStream { public void trunc() { pos = count = 0; } - public truncableBufferedInputStream(InputStream in) { + public TruncableBufferedInputStream(InputStream in) { super(in); } - public truncableBufferedInputStream(InputStream in, int size) { + public TruncableBufferedInputStream(InputStream in, int size) { super(in, size); } } @@ -87,7 +87,7 @@ public int emit(byte[] buf, int offset, int ndesired) { } }; - public static class chunkState { + public static class ChunkState { /** * Chunk Size. Must be same across all implementations */ @@ -96,8 +96,8 @@ public static class chunkState { private int chunk_size_ = DEFAULT_CHUNK_SIZE; private long offset_ = 0; - public chunkState() {} - public chunkState(int chunk_size) { chunk_size_ = chunk_size; } + public ChunkState() {} + public ChunkState(int chunk_size) { chunk_size_ = chunk_size; } public void skip(int size) {offset_ += size; } public void seek(long offset) {offset_ = offset;} @@ -108,7 +108,7 @@ public chunkState() {} public long getOffset() { return (offset_);} } - public static enum tailPolicy { + public static enum TailPolicy { NOWAIT(0, 0), WAIT_FOREVER(500, -1); @@ -133,7 +133,7 @@ public static enum tailPolicy { * @param retries number of retries */ - tailPolicy(int timeout, int retries) { + TailPolicy(int timeout, int retries) { timeout_ = timeout; retries_ = retries; } @@ -142,7 +142,7 @@ public static enum tailPolicy { /** * Current tailing policy */ - tailPolicy currentPolicy_ = tailPolicy.NOWAIT; + TailPolicy currentPolicy_ = TailPolicy.NOWAIT; /** @@ -169,12 +169,7 @@ public static enum tailPolicy { /** * current Chunk state */ - chunkState cs = null; - - /** - * Read timeout - */ - private int readTimeout_ = 0; + ChunkState cs = null; /** * is read only? @@ -186,7 +181,7 @@ public static enum tailPolicy { * * @return current read policy */ - public tailPolicy getTailPolicy() { + public TailPolicy getTailPolicy() { return (currentPolicy_); } @@ -196,8 +191,8 @@ public tailPolicy getTailPolicy() { * @param policy New policy to set * @return Old policy */ - public tailPolicy setTailPolicy(tailPolicy policy) { - tailPolicy old = currentPolicy_; + public TailPolicy setTailPolicy(TailPolicy policy) { + TailPolicy old = currentPolicy_; currentPolicy_ = policy; return (old); } @@ -212,10 +207,10 @@ private InputStream createInputStream() throws TTransportException { InputStream is; try { if(inputStream_ != null) { - ((truncableBufferedInputStream)inputStream_).trunc(); + ((TruncableBufferedInputStream)inputStream_).trunc(); is = inputStream_; } else { - is = new truncableBufferedInputStream(inputFile_.getInputStream()); + is = new TruncableBufferedInputStream(inputFile_.getInputStream()); } } catch (IOException iox) { System.err.println("createInputStream: "+iox.getMessage()); @@ -236,7 +231,7 @@ private InputStream createInputStream() throws TTransportException { * @return number of bytes read */ private int tailRead(InputStream is, byte[] buf, - int off, int len, tailPolicy tp) throws TTransportException { + int off, int len, TailPolicy tp) throws TTransportException { int orig_len = len; try { int retries = 0; @@ -369,7 +364,7 @@ public void open() throws TTransportException { try { inputStream_ = createInputStream(); - cs = new chunkState(); + cs = new ChunkState(); currentEvent_ = new Event(new byte [256]); if(!readOnly_) @@ -545,7 +540,7 @@ public void seekToChunk(int chunk) throws TTransportException { if(seekToEnd) { // waiting forever here - otherwise we can hit EOF and end up // having consumed partial data from the data stream. - tailPolicy old = setTailPolicy(tailPolicy.WAIT_FOREVER); + TailPolicy old = setTailPolicy(TailPolicy.WAIT_FOREVER); while(cs.getOffset() < eofOffset) { readEvent(); } currentEvent_.setAvailable(0); setTailPolicy(old); diff --git a/app/src/main/java/org/apache/thrift/transport/TMemoryBuffer.java b/app/src/main/java/org/apache/thrift/transport/TMemoryBuffer.java index 53354af..ef5f5c2 100644 --- a/app/src/main/java/org/apache/thrift/transport/TMemoryBuffer.java +++ b/app/src/main/java/org/apache/thrift/transport/TMemoryBuffer.java @@ -77,12 +77,12 @@ public String toString(String enc) throws UnsupportedEncodingException { } public String inspect() { - String buf = ""; + StringBuilder buf = new StringBuilder(); byte[] bytes = arr_.toByteArray(); for (int i = 0; i < bytes.length; i++) { - buf += (pos_ == i ? "==>" : "" ) + Integer.toHexString(bytes[i] & 0xff) + " "; + buf.append(pos_ == i ? "==>" : "" ).append(Integer.toHexString(bytes[i] & 0xff)).append(" "); } - return buf; + return buf.toString(); } // The contents of the buffer diff --git a/app/src/main/java/org/apache/thrift/transport/TNonblockingServerSocket.java b/app/src/main/java/org/apache/thrift/transport/TNonblockingServerSocket.java index 25b487e..44fe273 100644 --- a/app/src/main/java/org/apache/thrift/transport/TNonblockingServerSocket.java +++ b/app/src/main/java/org/apache/thrift/transport/TNonblockingServerSocket.java @@ -37,7 +37,7 @@ * Wrapper around ServerSocketChannel */ public class TNonblockingServerSocket extends TNonblockingServerTransport { - private static final Logger LOGGER = LoggerFactory.getLogger(TNonblockingServerTransport.class.getName()); + private static final Logger LOGGER = LoggerFactory.getLogger(TNonblockingServerSocket.class.getName()); /** * This channel is where all the nonblocking magic happens. @@ -54,6 +54,9 @@ public class TNonblockingServerSocket extends TNonblockingServerTransport { */ private int clientTimeout_ = 0; + public static class NonblockingAbstractServerSocketArgs extends + AbstractServerTransportArgs<NonblockingAbstractServerSocketArgs> {} + /** * Creates just a port listening server socket */ @@ -65,7 +68,7 @@ public TNonblockingServerSocket(int port) throws TTransportException { * Creates just a port listening server socket */ public TNonblockingServerSocket(int port, int clientTimeout) throws TTransportException { - this(new InetSocketAddress(port), clientTimeout); + this(new NonblockingAbstractServerSocketArgs().port(port).clientTimeout(clientTimeout)); } public TNonblockingServerSocket(InetSocketAddress bindAddr) throws TTransportException { @@ -73,7 +76,11 @@ public TNonblockingServerSocket(InetSocketAddress bindAddr) throws TTransportExc } public TNonblockingServerSocket(InetSocketAddress bindAddr, int clientTimeout) throws TTransportException { - clientTimeout_ = clientTimeout; + this(new NonblockingAbstractServerSocketArgs().bindAddr(bindAddr).clientTimeout(clientTimeout)); + } + + public TNonblockingServerSocket(NonblockingAbstractServerSocketArgs args) throws TTransportException { + clientTimeout_ = args.clientTimeout; try { serverSocketChannel = ServerSocketChannel.open(); serverSocketChannel.configureBlocking(false); @@ -83,10 +90,10 @@ public TNonblockingServerSocket(InetSocketAddress bindAddr, int clientTimeout) t // Prevent 2MSL delay problem on server restarts serverSocket_.setReuseAddress(true); // Bind to listening port - serverSocket_.bind(bindAddr); + serverSocket_.bind(args.bindAddr, args.backlog); } catch (IOException ioe) { serverSocket_ = null; - throw new TTransportException("Could not create ServerSocket on address " + bindAddr.toString() + "."); + throw new TTransportException("Could not create ServerSocket on address " + args.bindAddr.toString() + "."); } } @@ -147,4 +154,10 @@ public void interrupt() { close(); } + public int getPort() { + if (serverSocket_ == null) + return -1; + return serverSocket_.getLocalPort(); + } + } diff --git a/app/src/main/java/org/apache/thrift/transport/TNonblockingSocket.java b/app/src/main/java/org/apache/thrift/transport/TNonblockingSocket.java index 482bd14..23f8574 100644 --- a/app/src/main/java/org/apache/thrift/transport/TNonblockingSocket.java +++ b/app/src/main/java/org/apache/thrift/transport/TNonblockingSocket.java @@ -85,6 +85,7 @@ private TNonblockingSocket(SocketChannel socketChannel, int timeout, SocketAddre Socket socket = socketChannel.socket(); socket.setSoLinger(false, 0); socket.setTcpNoDelay(true); + socket.setKeepAlive(true); setTimeout(timeout); } diff --git a/app/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java b/app/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java index 86d4913..ef70b75 100644 --- a/app/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java +++ b/app/src/main/java/org/apache/thrift/transport/TSSLTransportFactory.java @@ -20,8 +20,14 @@ package org.apache.thrift.transport; import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.InputStream; +import java.io.IOException; import java.net.InetAddress; +import java.net.URL; +import java.net.MalformedURLException; import java.security.KeyStore; +import java.util.Arrays; import javax.net.ssl.KeyManagerFactory; import javax.net.ssl.SSLContext; @@ -32,7 +38,7 @@ import javax.net.ssl.TrustManagerFactory; /** - * A Factory for providing and setting up Client and Server SSL wrapped + * A Factory for providing and setting up Client and Server SSL wrapped * TSocket and TServerSocket */ public class TSSLTransportFactory { @@ -41,24 +47,24 @@ public class TSSLTransportFactory { * Get a SSL wrapped TServerSocket bound to the specified port. In this * configuration the default settings are used. Default settings are retrieved * from System properties that are set. - * + * * Example system properties: * -Djavax.net.ssl.trustStore=<truststore location> * -Djavax.net.ssl.trustStorePassword=password * -Djavax.net.ssl.keyStore=<keystore location> * -Djavax.net.ssl.keyStorePassword=password - * + * * @param port * @return A SSL wrapped TServerSocket * @throws TTransportException */ public static TServerSocket getServerSocket(int port) throws TTransportException { - return getServerSocket(port, 0); + return getServerSocket(port, 0); } /** * Get a default SSL wrapped TServerSocket bound to the specified port - * + * * @param port * @param clientTimeout * @return A SSL wrapped TServerSocket @@ -70,7 +76,7 @@ public static TServerSocket getServerSocket(int port, int clientTimeout) throws /** * Get a default SSL wrapped TServerSocket bound to the specified port and interface - * + * * @param port * @param clientTimeout * @param ifAddress @@ -79,14 +85,14 @@ public static TServerSocket getServerSocket(int port, int clientTimeout) throws */ public static TServerSocket getServerSocket(int port, int clientTimeout, boolean clientAuth, InetAddress ifAddress) throws TTransportException { SSLServerSocketFactory factory = (SSLServerSocketFactory) SSLServerSocketFactory.getDefault(); - return createServer(factory, port, clientTimeout, clientAuth, ifAddress, null); + return createServer(factory, port, clientTimeout, clientAuth, ifAddress, null); } /** - * Get a configured SSL wrapped TServerSocket bound to the specified port and interface. - * Here the TSSLTransportParameters are used to set the values for the algorithms, keystore, + * Get a configured SSL wrapped TServerSocket bound to the specified port and interface. + * Here the TSSLTransportParameters are used to set the values for the algorithms, keystore, * truststore and other settings - * + * * @param port * @param clientTimeout * @param ifAddress @@ -112,7 +118,8 @@ private static TServerSocket createServer(SSLServerSocketFactory factory, int po if (params != null && params.cipherSuites != null) { serverSocket.setEnabledCipherSuites(params.cipherSuites); } - return new TServerSocket(serverSocket); + return new TServerSocket(new TServerSocket.ServerSocketTransportArgs(). + serverSocket(serverSocket).clientTimeout(timeout)); } catch (Exception e) { throw new TTransportException("Could not bind to port " + port, e); } @@ -120,9 +127,9 @@ private static TServerSocket createServer(SSLServerSocketFactory factory, int po /** * Get a default SSL wrapped TSocket connected to the specified host and port. All - * the client methods return a bound connection. So there is no need to call open() on the + * the client methods return a bound connection. So there is no need to call open() on the * TTransport. - * + * * @param host * @param port * @param timeout @@ -136,7 +143,7 @@ public static TSocket getClientSocket(String host, int port, int timeout) throws /** * Get a default SSL wrapped TSocket connected to the specified host and port. - * + * * @param host * @param port * @return A SSL wrapped TSocket @@ -147,9 +154,9 @@ public static TSocket getClientSocket(String host, int port) throws TTransportEx } /** - * Get a custom configured SSL wrapped TSocket. The SSL settings are obtained from the + * Get a custom configured SSL wrapped TSocket. The SSL settings are obtained from the * passed in TSSLTransportParameters. - * + * * @param host * @param port * @param timeout @@ -168,6 +175,9 @@ public static TSocket getClientSocket(String host, int port, int timeout, TSSLTr private static SSLContext createSSLContext(TSSLTransportParameters params) throws TTransportException { SSLContext ctx; + InputStream in = null; + InputStream is = null; + try { ctx = SSLContext.getInstance(params.protocol); TrustManagerFactory tmf = null; @@ -176,14 +186,17 @@ private static SSLContext createSSLContext(TSSLTransportParameters params) throw if (params.isTrustStoreSet) { tmf = TrustManagerFactory.getInstance(params.trustManagerType); KeyStore ts = KeyStore.getInstance(params.trustStoreType); - ts.load(new FileInputStream(params.trustStore), params.trustPass.toCharArray()); + in = getStoreAsStream(params.trustStore); + ts.load(in, + (params.trustPass != null ? params.trustPass.toCharArray() : null)); tmf.init(ts); } if (params.isKeyStoreSet) { kmf = KeyManagerFactory.getInstance(params.keyManagerType); KeyStore ks = KeyStore.getInstance(params.keyStoreType); - ks.load(new FileInputStream(params.keyStore), params.keyPass.toCharArray()); + is = getStoreAsStream(params.keyStore); + ks.load(is, params.keyPass.toCharArray()); kmf.init(ks, params.keyPass.toCharArray()); } @@ -199,10 +212,50 @@ else if (params.isKeyStoreSet) { } catch (Exception e) { throw new TTransportException("Error creating the transport", e); + } finally { + if (in != null) { + try { + in.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + if (is != null) { + try { + is.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } } + return ctx; } + private static InputStream getStoreAsStream(String store) throws IOException { + try { + return new FileInputStream(store); + } catch(FileNotFoundException e) { + } + + InputStream storeStream = null; + try { + storeStream = new URL(store).openStream(); + if (storeStream != null) { + return storeStream; + } + } catch(MalformedURLException e) { + } + + storeStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(store); + + if (storeStream != null) { + return storeStream; + } else { + throw new IOException("Could not load file: " + store); + } + } + public static TSocket createClient(SSLSocketFactory factory, String host, int port, int timeout) throws TTransportException { try { SSLSocket socket = (SSLSocket) factory.createSocket(host, port); @@ -236,7 +289,7 @@ public TSSLTransportParameters() {} /** * Create parameters specifying the protocol and cipher suites - * + * * @param protocol The specific protocol (TLS/SSL) can be specified with versions * @param cipherSuites */ @@ -247,7 +300,7 @@ public TSSLTransportParameters(String protocol, String[] cipherSuites) { /** * Create parameters specifying the protocol, cipher suites and if client authentication * is required - * + * * @param protocol The specific protocol (TLS/SSL) can be specified with versions * @param cipherSuites * @param clientAuth @@ -256,13 +309,13 @@ public TSSLTransportParameters(String protocol, String[] cipherSuites, boolean c if (protocol != null) { this.protocol = protocol; } - this.cipherSuites = cipherSuites; + this.cipherSuites = Arrays.copyOf(cipherSuites, cipherSuites.length); this.clientAuth = clientAuth; } /** * Set the keystore, password, certificate type and the store type - * + * * @param keyStore Location of the Keystore on disk * @param keyPass Keystore password * @param keyManagerType The default is X509 @@ -282,7 +335,7 @@ public void setKeyStore(String keyStore, String keyPass, String keyManagerType, /** * Set the keystore and password - * + * * @param keyStore Location of the Keystore on disk * @param keyPass Keystore password */ @@ -292,7 +345,7 @@ public void setKeyStore(String keyStore, String keyPass) { /** * Set the truststore, password, certificate type and the store type - * + * * @param trustStore Location of the Truststore on disk * @param trustPass Truststore password * @param trustManagerType The default is X509 @@ -312,7 +365,7 @@ public void setTrustStore(String trustStore, String trustPass, String trustManag /** * Set the truststore and password - * + * * @param trustStore Location of the Truststore on disk * @param trustPass Truststore password */ @@ -322,7 +375,7 @@ public void setTrustStore(String trustStore, String trustPass) { /** * Set if client authentication is required - * + * * @param clientAuth */ public void requireClientAuth(boolean clientAuth) { diff --git a/app/src/main/java/org/apache/thrift/transport/TServerSocket.java b/app/src/main/java/org/apache/thrift/transport/TServerSocket.java index 147074a..7bd87f4 100644 --- a/app/src/main/java/org/apache/thrift/transport/TServerSocket.java +++ b/app/src/main/java/org/apache/thrift/transport/TServerSocket.java @@ -46,19 +46,27 @@ public class TServerSocket extends TServerTransport { */ private int clientTimeout_ = 0; + public static class ServerSocketTransportArgs extends AbstractServerTransportArgs<ServerSocketTransportArgs> { + ServerSocket serverSocket; + + public ServerSocketTransportArgs serverSocket(ServerSocket serverSocket) { + this.serverSocket = serverSocket; + return this; + } + } + /** * Creates a server socket from underlying socket object */ - public TServerSocket(ServerSocket serverSocket) { + public TServerSocket(ServerSocket serverSocket) throws TTransportException { this(serverSocket, 0); } /** * Creates a server socket from underlying socket object */ - public TServerSocket(ServerSocket serverSocket, int clientTimeout) { - serverSocket_ = serverSocket; - clientTimeout_ = clientTimeout; + public TServerSocket(ServerSocket serverSocket, int clientTimeout) throws TTransportException { + this(new ServerSocketTransportArgs().serverSocket(serverSocket).clientTimeout(clientTimeout)); } /** @@ -80,17 +88,25 @@ public TServerSocket(InetSocketAddress bindAddr) throws TTransportException { } public TServerSocket(InetSocketAddress bindAddr, int clientTimeout) throws TTransportException { - clientTimeout_ = clientTimeout; + this(new ServerSocketTransportArgs().bindAddr(bindAddr).clientTimeout(clientTimeout)); + } + + public TServerSocket(ServerSocketTransportArgs args) throws TTransportException { + clientTimeout_ = args.clientTimeout; + if (args.serverSocket != null) { + this.serverSocket_ = args.serverSocket; + return; + } try { // Make server socket serverSocket_ = new ServerSocket(); // Prevent 2MSL delay problem on server restarts serverSocket_.setReuseAddress(true); // Bind to listening port - serverSocket_.bind(bindAddr); + serverSocket_.bind(args.bindAddr, args.backlog); } catch (IOException ioe) { - serverSocket_ = null; - throw new TTransportException("Could not create ServerSocket on address " + bindAddr.toString() + "."); + close(); + throw new TTransportException("Could not create ServerSocket on address " + args.bindAddr.toString() + ".", ioe); } } diff --git a/app/src/main/java/org/apache/thrift/transport/TServerTransport.java b/app/src/main/java/org/apache/thrift/transport/TServerTransport.java index 17ff86b..424e4fa 100644 --- a/app/src/main/java/org/apache/thrift/transport/TServerTransport.java +++ b/app/src/main/java/org/apache/thrift/transport/TServerTransport.java @@ -19,11 +19,40 @@ package org.apache.thrift.transport; +import java.io.Closeable; +import java.net.InetSocketAddress; + /** * Server transport. Object which provides client transports. * */ -public abstract class TServerTransport { +public abstract class TServerTransport implements Closeable { + + public static abstract class AbstractServerTransportArgs<T extends AbstractServerTransportArgs<T>> { + int backlog = 0; // A value of 0 means the default value will be used (currently set at 50) + int clientTimeout = 0; + InetSocketAddress bindAddr; + + public T backlog(int backlog) { + this.backlog = backlog; + return (T) this; + } + + public T clientTimeout(int clientTimeout) { + this.clientTimeout = clientTimeout; + return (T) this; + } + + public T port(int port) { + this.bindAddr = new InetSocketAddress(port); + return (T) this; + } + + public T bindAddr(InetSocketAddress bindAddr) { + this.bindAddr = bindAddr; + return (T) this; + } + } public abstract void listen() throws TTransportException; diff --git a/app/src/main/java/org/apache/thrift/transport/TSimpleFileTransport.java b/app/src/main/java/org/apache/thrift/transport/TSimpleFileTransport.java new file mode 100644 index 0000000..42102d9 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/transport/TSimpleFileTransport.java @@ -0,0 +1,216 @@ +/* + * 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.thrift.transport; + +import java.io.IOException; +import java.io.RandomAccessFile; + + +/** + * Basic file support for the TTransport interface + */ +public final class TSimpleFileTransport extends TTransport { + + private RandomAccessFile file = null; + private boolean readable; + private boolean writable; + private String path_; + + + /** + * Create a transport backed by a simple file + * + * @param path the path to the file to open/create + * @param read true to support read operations + * @param write true to support write operations + * @param openFile true to open the file on construction + * @throws TTransportException if file open fails + */ + public TSimpleFileTransport(String path, boolean read, + boolean write, boolean openFile) + throws TTransportException { + if (path.length() <= 0) { + throw new TTransportException("No path specified"); + } + if (!read && !write) { + throw new TTransportException("Neither READ nor WRITE specified"); + } + readable = read; + writable = write; + path_ = path; + if (openFile) { + open(); + } + } + + /** + * Create a transport backed by a simple file + * Implicitly opens file to conform to C++ behavior. + * + * @param path the path to the file to open/create + * @param read true to support read operations + * @param write true to support write operations + * @throws TTransportException if file open fails + */ + public TSimpleFileTransport(String path, boolean read, boolean write) + throws TTransportException { + this(path, read, write, true); + } + + /** + * Create a transport backed by a simple read only disk file (implicitly opens + * file) + * + * @param path the path to the file to open/create + * @throws TTransportException if file open fails + */ + public TSimpleFileTransport(String path) throws TTransportException { + this(path, true, false, true); + } + + /** + * Test file status + * + * @return true if open, otherwise false + */ + @Override + public boolean isOpen() { + return (file != null); + } + + /** + * Open file if not previously opened. + * + * @throws TTransportException if open fails + */ + @Override + public void open() throws TTransportException { + if (file == null){ + try { + String access = "r"; //RandomAccessFile objects must be readable + if (writable) { + access += "w"; + } + file = new RandomAccessFile(path_, access); + } catch (IOException ioe) { + file = null; + throw new TTransportException(ioe.getMessage()); + } + } + } + + /** + * Close file, subsequent read/write activity will throw exceptions + */ + @Override + public void close() { + if (file != null) { + try { + file.close(); + } catch (Exception e) { + //Nothing to do + } + file = null; + } + } + + /** + * Read up to len many bytes into buf at offset + * + * @param buf houses bytes read + * @param off offset into buff to begin writing to + * @param len maximum number of bytes to read + * @return number of bytes actually read + * @throws TTransportException on read failure + */ + @Override + public int read(byte[] buf, int off, int len) throws TTransportException { + if (!readable) { + throw new TTransportException("Read operation on write only file"); + } + int iBytesRead = 0; + try { + iBytesRead = file.read(buf, off, len); + } catch (IOException ioe) { + file = null; + throw new TTransportException(ioe.getMessage()); + } + return iBytesRead; + } + + /** + * Write len many bytes from buff starting at offset + * + * @param buf buffer containing bytes to write + * @param off offset into buffer to begin writing from + * @param len number of bytes to write + * @throws TTransportException on write failure + */ + @Override + public void write(byte[] buf, int off, int len) throws TTransportException { + try { + file.write(buf, off, len); + } catch (IOException ioe) { + file = null; + throw new TTransportException(ioe.getMessage()); + } + } + + /** + * Move file pointer to specified offset, new read/write calls will act here + * + * @param offset bytes from beginning of file to move pointer to + * @throws TTransportException is seek fails + */ + public void seek(long offset) throws TTransportException { + try { + file.seek(offset); + } catch (IOException ex) { + throw new TTransportException(ex.getMessage()); + } + } + + /** + * Return the length of the file in bytes + * + * @return length of the file in bytes + * @throws TTransportException if file access fails + */ + public long length() throws TTransportException { + try { + return file.length(); + } catch (IOException ex) { + throw new TTransportException(ex.getMessage()); + } + } + + /** + * Return current file pointer position in bytes from beginning of file + * + * @return file pointer position + * @throws TTransportException if file access fails + */ + public long getFilePointer() throws TTransportException { + try { + return file.getFilePointer(); + } catch (IOException ex) { + throw new TTransportException(ex.getMessage()); + } + } +} \ No newline at end of file diff --git a/app/src/main/java/org/apache/thrift/transport/TSocket.java b/app/src/main/java/org/apache/thrift/transport/TSocket.java index 606e8a9..bc44209 100644 --- a/app/src/main/java/org/apache/thrift/transport/TSocket.java +++ b/app/src/main/java/org/apache/thrift/transport/TSocket.java @@ -53,9 +53,14 @@ public class TSocket extends TIOStreamTransport { private int port_ = 0; /** - * Socket timeout + * Socket timeout - read timeout on the socket */ - private int timeout_ = 0; + private int socketTimeout_ = 0; + + /** + * Connection timeout + */ + private int connectTimeout_ = 0; /** * Constructor that takes an already created socket. @@ -68,6 +73,7 @@ public TSocket(Socket socket) throws TTransportException { try { socket_.setSoLinger(false, 0); socket_.setTcpNoDelay(true); + socket_.setKeepAlive(true); } catch (SocketException sx) { LOGGER.warn("Could not configure socket.", sx); } @@ -100,12 +106,27 @@ public TSocket(String host, int port) { * * @param host Remote host * @param port Remote port - * @param timeout Socket timeout + * @param timeout Socket timeout and connection timeout */ public TSocket(String host, int port, int timeout) { + this(host, port, timeout, timeout); + } + + /** + * Creates a new unconnected socket that will connect to the given host + * on the given port, with a specific connection timeout and a + * specific socket timeout. + * + * @param host Remote host + * @param port Remote port + * @param socketTimeout Socket timeout + * @param connectTimeout Connection timeout + */ + public TSocket(String host, int port, int socketTimeout, int connectTimeout) { host_ = host; port_ = port; - timeout_ = timeout; + socketTimeout_ = socketTimeout; + connectTimeout_ = connectTimeout; initSocket(); } @@ -117,19 +138,39 @@ private void initSocket() { try { socket_.setSoLinger(false, 0); socket_.setTcpNoDelay(true); - socket_.setSoTimeout(timeout_); + socket_.setKeepAlive(true); + socket_.setSoTimeout(socketTimeout_); } catch (SocketException sx) { LOGGER.error("Could not configure socket.", sx); } } /** - * Sets the socket timeout + * Sets the socket timeout and connection timeout. * * @param timeout Milliseconds timeout */ public void setTimeout(int timeout) { - timeout_ = timeout; + this.setConnectTimeout(timeout); + this.setSocketTimeout(timeout); + } + + /** + * Sets the time after which the connection attempt will time out + * + * @param timeout Milliseconds timeout + */ + public void setConnectTimeout(int timeout) { + connectTimeout_ = timeout; + } + + /** + * Sets the socket timeout + * + * @param timeout Milliseconds timeout + */ + public void setSocketTimeout(int timeout) { + socketTimeout_ = timeout; try { socket_.setSoTimeout(timeout); } catch (SocketException sx) { @@ -177,7 +218,7 @@ public void open() throws TTransportException { } try { - socket_.connect(new InetSocketAddress(host_, port_), timeout_); + socket_.connect(new InetSocketAddress(host_, port_), connectTimeout_); inputStream_ = new BufferedInputStream(socket_.getInputStream(), 1024); outputStream_ = new BufferedOutputStream(socket_.getOutputStream(), 1024); } catch (IOException iox) { diff --git a/app/src/main/java/org/apache/thrift/transport/TTransport.java b/app/src/main/java/org/apache/thrift/transport/TTransport.java index 6eab3b0..73ad730 100644 --- a/app/src/main/java/org/apache/thrift/transport/TTransport.java +++ b/app/src/main/java/org/apache/thrift/transport/TTransport.java @@ -19,12 +19,14 @@ package org.apache.thrift.transport; +import java.io.Closeable; + /** * Generic class that encapsulates the I/O layer. This is basically a thin * wrapper around the combined functionality of Java input/output streams. * */ -public abstract class TTransport { +public abstract class TTransport implements Closeable { /** * Queries whether the transport is open. diff --git a/app/src/main/java/org/apache/thrift/transport/TZlibTransport.java b/app/src/main/java/org/apache/thrift/transport/TZlibTransport.java new file mode 100644 index 0000000..df4de13 --- /dev/null +++ b/app/src/main/java/org/apache/thrift/transport/TZlibTransport.java @@ -0,0 +1,148 @@ +/* + * 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.thrift.transport; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.zip.Deflater; +import java.util.zip.DeflaterOutputStream; +import java.util.zip.Inflater; +import java.util.zip.InflaterInputStream; + +/** + * TZlibTransport deflates on write and inflates on read. + */ +public class TZlibTransport extends TIOStreamTransport { + + private TTransport transport_ = null; + + public static class Factory extends TTransportFactory { + public Factory() { + } + + @Override + public TTransport getTransport(TTransport base) { + return new TZlibTransport(base); + } + } + + /** + * Constructs a new TZlibTransport instance. + * @param transport the underlying transport to read from and write to + */ + public TZlibTransport(TTransport transport) { + this(transport, Deflater.BEST_COMPRESSION); + } + + /** + * Constructs a new TZlibTransport instance. + * @param transport the underlying transport to read from and write to + * @param compressionLevel 0 for no compression, 9 for maximum compression + */ + public TZlibTransport(TTransport transport, int compressionLevel) { + transport_ = transport; + inputStream_ = new InflaterInputStream(new TTransportInputStream(transport_), new Inflater()); + outputStream_ = new DeflaterOutputStream(new TTransportOutputStream(transport_), new Deflater(compressionLevel, false), true); + } + + @Override + public boolean isOpen() { + return transport_.isOpen(); + } + + @Override + public void open() throws TTransportException { + transport_.open(); + } + + @Override + public void close() { + if (transport_.isOpen()) { + transport_.close(); + } + } + +} + +class TTransportInputStream extends InputStream { + + private TTransport transport = null; + + public TTransportInputStream(TTransport transport) { + this.transport = transport; + } + + @Override + public int read() throws IOException { + try { + byte[] buf = new byte[1]; + transport.read(buf, 0, 1); + return buf[0]; + } catch (TTransportException e) { + throw new IOException(e); + } + } + + @Override + public int read(byte b[], int off, int len) throws IOException { + try { + return transport.read(b, off, len); + } catch (TTransportException e) { + throw new IOException(e); + } + } +} + +class TTransportOutputStream extends OutputStream { + + private TTransport transport = null; + + public TTransportOutputStream(TTransport transport) { + this.transport = transport; + } + + @Override + public void write(final int b) throws IOException { + try { + transport.write(new byte[]{(byte) b}); + } catch (TTransportException e) { + throw new IOException(e); + } + } + + @Override + public void write(byte b[], int off, int len) throws IOException { + try { + transport.write(b, off, len); + } catch (TTransportException e) { + throw new IOException(e); + } + } + + @Override + public void flush() throws IOException { + try { + transport.flush(); + } catch (TTransportException e) { + throw new IOException(e); + } + } +} + diff --git a/app/src/main/java/org/pyload/android/client/Preferences.java b/app/src/main/java/org/pyload/android/client/Preferences.java index 70f1d5a..7ec467a 100644 --- a/app/src/main/java/org/pyload/android/client/Preferences.java +++ b/app/src/main/java/org/pyload/android/client/Preferences.java @@ -5,6 +5,9 @@ import android.view.MenuItem; public class Preferences extends PreferenceActivity { + + public static final String CHECK_CAPTCHA_SERVICE_ENABLE = "check_captcha_bg"; + @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); diff --git a/app/src/main/java/org/pyload/android/client/dialogs/AccountDialog.java b/app/src/main/java/org/pyload/android/client/dialogs/AccountDialog.java index cf02a7d..647e398 100644 --- a/app/src/main/java/org/pyload/android/client/dialogs/AccountDialog.java +++ b/app/src/main/java/org/pyload/android/client/dialogs/AccountDialog.java @@ -5,12 +5,15 @@ import android.content.Context; import android.os.Bundle; import android.support.v4.app.DialogFragment; +import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.BaseAdapter; import android.widget.ListView; import android.widget.TextView; + +import org.apache.thrift.TException; import org.pyload.android.client.R; import org.pyload.android.client.module.GuiTask; import org.pyload.android.client.module.Utils; @@ -32,8 +35,15 @@ public Dialog onCreateDialog(Bundle savedInstanceState) { final pyLoadApp app = (pyLoadApp) getActivity().getApplication(); GuiTask task = new GuiTask(new Runnable() { public void run() { - Pyload.Client client = app.getClient(); - adapter.setData(client.getAccounts(false)); + Pyload.Client client = null; + try { + client = app.getClient(); + synchronized (client) { + adapter.setData(client.getAccounts(false)); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } } }); app.addTask(task); diff --git a/app/src/main/java/org/pyload/android/client/fragments/AbstractPackageFragment.java b/app/src/main/java/org/pyload/android/client/fragments/AbstractPackageFragment.java index 47baae2..42e5580 100644 --- a/app/src/main/java/org/pyload/android/client/fragments/AbstractPackageFragment.java +++ b/app/src/main/java/org/pyload/android/client/fragments/AbstractPackageFragment.java @@ -5,6 +5,7 @@ import java.util.Comparator; import java.util.List; +import org.apache.thrift.TException; import org.pyload.android.client.R; import org.pyload.android.client.module.Utils; import org.pyload.android.client.pyLoadApp; @@ -132,8 +133,15 @@ public boolean onContextItemSelected(MenuItem item) { app.addTask(new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - client.restartFile(file.fid); + try { + client = app.getClient(); + synchronized (client) { + client.restartFile(file.fid); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } }, app.handleSuccess)); @@ -143,11 +151,17 @@ public void run() { app.addTask(new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - ArrayList<Integer> fids = new ArrayList<Integer>(); - fids.add(file.fid); + try { + client = app.getClient(); + ArrayList<Integer> fids = new ArrayList<Integer>(); + fids.add(file.fid); + synchronized (client) { + client.deleteFiles(fids); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } - client.deleteFiles(fids); } }, app.handleSuccess)); @@ -180,8 +194,15 @@ public void run() { app.addTask(new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - client.restartPackage(pack.pid); + try { + client = app.getClient(); + synchronized (client) { + client.restartPackage(pack.pid); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } }, app.handleSuccess)); @@ -191,10 +212,17 @@ public void run() { app.addTask(new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - ArrayList<Integer> pids = new ArrayList<Integer>(); - pids.add(pack.pid); - client.deletePackages(pids); + try { + client = app.getClient(); + ArrayList<Integer> pids = new ArrayList<Integer>(); + pids.add(pack.pid); + synchronized (client) { + client.deletePackages(pids); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } }, app.handleSuccess)); @@ -205,15 +233,21 @@ public void run() { app.addTask(new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - Destination newDest; - if (dest == 0) { - newDest = Destination.Collector; - } else { - newDest = Destination.Queue; + try { + client = app.getClient(); + Destination newDest; + if (dest == 0) { + newDest = Destination.Collector; + } else { + newDest = Destination.Queue; + } + synchronized (client) { + client.movePackage(newDest, pack.pid); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); } - client.movePackage(newDest, pack.pid); } }, app.handleSuccess)); @@ -293,11 +327,18 @@ public void refresh() { GuiTask task = new GuiTask(new Runnable() { public void run() { - client = app.getClient(); - if (dest == 0) - data = client.getQueueData(); - else - data = client.getCollectorData(); + try { + client = app.getClient(); + synchronized (client) { + if (dest == 0) + data = client.getQueueData(); + else + data = client.getCollectorData(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } }, mUpdateResults); diff --git a/app/src/main/java/org/pyload/android/client/fragments/ConfigSectionFragment.java b/app/src/main/java/org/pyload/android/client/fragments/ConfigSectionFragment.java index c91585e..655f8b4 100644 --- a/app/src/main/java/org/pyload/android/client/fragments/ConfigSectionFragment.java +++ b/app/src/main/java/org/pyload/android/client/fragments/ConfigSectionFragment.java @@ -3,6 +3,7 @@ import java.util.ArrayList; import java.util.HashMap; +import org.apache.thrift.TException; import org.pyload.android.client.R; import org.pyload.android.client.pyLoadApp; import org.pyload.android.client.module.GuiTask; @@ -107,22 +108,30 @@ public void onSubmit() { @Override public void run() { - Client client = app.getClient(); - - for (ConfigItem item : section.items) { - ConfigItemView view = items.get(item.name); - String newValue = view.getValue(); - if (!item.value.equals(newValue)) { - Log.d("pyLoad", String.format( - "Set config value: %s, %s, %s", type, - section.name, item.name)); - - client.setConfigValue(section.name, item.name, - newValue, type); + Client client = null; + try { + client = app.getClient(); + for (ConfigItem item : section.items) { + ConfigItemView view = items.get(item.name); + String newValue = view.getValue(); + if (!item.value.equals(newValue)) { + Log.d("pyLoad", String.format( + "Set config value: %s, %s, %s", type, + section.name, item.name)); + + synchronized (client) { + client.setConfigValue(section.name, item.name, + newValue, type); + } + } } + + getFragmentManager().popBackStack(); + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); } - getFragmentManager().popBackStack(); + } diff --git a/app/src/main/java/org/pyload/android/client/fragments/OverviewFragment.java b/app/src/main/java/org/pyload/android/client/fragments/OverviewFragment.java index c9113f6..aea0180 100644 --- a/app/src/main/java/org/pyload/android/client/fragments/OverviewFragment.java +++ b/app/src/main/java/org/pyload/android/client/fragments/OverviewFragment.java @@ -1,20 +1,5 @@ package org.pyload.android.client.fragments; -import java.util.ArrayList; -import java.util.List; - -import org.pyload.android.client.R; -import org.pyload.android.client.module.Utils; -import org.pyload.android.client.pyLoadApp; -import org.pyload.android.client.components.TabHandler; -import org.pyload.android.client.dialogs.CaptchaDialog; -import org.pyload.android.client.module.GuiTask; -import org.pyload.thrift.CaptchaTask; -import org.pyload.thrift.DownloadInfo; -import org.pyload.thrift.DownloadStatus; -import org.pyload.thrift.Pyload.Client; -import org.pyload.thrift.ServerStatus; - import android.content.Context; import android.content.DialogInterface; import android.content.DialogInterface.OnDismissListener; @@ -34,98 +19,120 @@ import android.widget.ProgressBar; import android.widget.TextView; +import org.apache.thrift.TException; +import org.pyload.android.client.R; +import org.pyload.android.client.components.TabHandler; +import org.pyload.android.client.dialogs.CaptchaDialog; +import org.pyload.android.client.module.GuiTask; +import org.pyload.android.client.module.Utils; +import org.pyload.android.client.pyLoadApp; +import org.pyload.thrift.CaptchaTask; +import org.pyload.thrift.DownloadInfo; +import org.pyload.thrift.DownloadStatus; +import org.pyload.thrift.Pyload.Client; +import org.pyload.thrift.ServerStatus; + +import java.util.ArrayList; +import java.util.List; + public class OverviewFragment extends ListFragment implements - OnDismissListener, TabHandler { - - public final static int CAPTCHA_DIALOG = 0; - - private pyLoadApp app; - private Client client; - private OverviewAdapter adp; - - private List<DownloadInfo> downloads; - private ServerStatus status; - private CaptchaTask captcha; - private int lastCaptcha = -1; - private int interval = 5; - private boolean update = false; - private boolean dialogOpen = false; - // tab position - private int pos = -1; - - /** - * GUI Elements - */ - private TextView statusServer; - private TextView reconnect; - private TextView speed; - private TextView active; - - private final Handler mHandler = new Handler(); - private final Runnable mUpdateResults = new Runnable() { - - public void run() { - onDataReceived(); - } - }; - private final Runnable runUpdate = new Runnable() { - - public void run() { - client = app.getClient(); - downloads = client.statusDownloads(); - status = client.statusServer(); - if (client.isCaptchaWaiting()) { - Log.d("pyLoad", "Captcha available"); - captcha = client.getCaptchaTask(false); - Log.d("pyload", captcha.resultType); - } - } - }; - - private final Runnable cancelUpdate = new Runnable() { - - public void run() { - stopUpdate(); - } - }; - - private final Runnable mUpdateTimeTask = new Runnable() { - public void run() { - refresh(); - if (update) - mHandler.postDelayed(this, interval * 1000); - } - }; - - @Override - public void onCreate(Bundle savedInstanceState) { - super.onCreate(savedInstanceState); - - app = (pyLoadApp) getActivity().getApplicationContext(); - - downloads = new ArrayList<DownloadInfo>(); - adp = new OverviewAdapter(app, R.layout.overview_item, downloads); - } - - public View onCreateView(LayoutInflater inflater, ViewGroup container, - Bundle savedInstanceState) { - - View v = inflater.inflate(R.layout.overview, null, false); - - statusServer = (TextView) v.findViewById(R.id.status_server); - reconnect = (TextView) v.findViewById(R.id.reconnect); - speed = (TextView) v.findViewById(R.id.speed); - active = (TextView) v.findViewById(R.id.active); + OnDismissListener, TabHandler { + + public final static int CAPTCHA_DIALOG = 0; + private final Handler mHandler = new Handler(); + private pyLoadApp app; + private Client client; + private OverviewAdapter adp; + private List<DownloadInfo> downloads; + private ServerStatus status; + private CaptchaTask captcha; + private int lastCaptcha = -1; + private int interval = 5; + private boolean update = false; + private final Runnable mUpdateTimeTask = new Runnable() { + public void run() { + refresh(); + if (update) + mHandler.postDelayed(this, interval * 1000); + } + }; + private final Runnable cancelUpdate = new Runnable() { + + public void run() { + stopUpdate(); + } + }; + private boolean dialogOpen = false; + // tab position + private int pos = -1; + /** + * GUI Elements + */ + private TextView statusServer; + private TextView reconnect; + private TextView speed; + private TextView active; + private final Runnable mUpdateResults = new Runnable() { + + public void run() { + onDataReceived(); + } + }; + private final Runnable runUpdate = new Runnable() { + + public void run() { + try { + client = app.getClient(); + synchronized (client) { + downloads = client.statusDownloads(); + status = client.statusServer(); + if (client.isCaptchaWaiting()) { + Log.d("pyLoad", "Captcha available"); + captcha = client.getCaptchaTask(false); + Log.d("pyload", captcha.resultType); + } + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } + }; + + @Override + public void onCreate(Bundle savedInstanceState) { + super.onCreate(savedInstanceState); + + app = (pyLoadApp) getActivity().getApplicationContext(); + + downloads = new ArrayList<DownloadInfo>(); + adp = new OverviewAdapter(app, R.layout.overview_item, downloads); + } + + public View onCreateView(LayoutInflater inflater, ViewGroup container, + Bundle savedInstanceState) { + + View v = inflater.inflate(R.layout.overview, null, false); + + statusServer = (TextView) v.findViewById(R.id.status_server); + reconnect = (TextView) v.findViewById(R.id.reconnect); + speed = (TextView) v.findViewById(R.id.speed); + active = (TextView) v.findViewById(R.id.active); // toggle pause on click statusServer.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { app.addTask(new GuiTask(new Runnable() { - public void run() { - Client client = app.getClient(); - client.togglePause(); - } - }, app.handleSuccess)); + public void run() { + try { + Client client = app.getClient(); + synchronized (client) { + client.togglePause(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } + }, app.handleSuccess)); } }); @@ -134,285 +141,296 @@ public void run() { public void onClick(View v) { app.addTask(new GuiTask(new Runnable() { public void run() { - Client client = app.getClient(); - client.toggleReconnect(); + try { + Client client = app.getClient(); + synchronized (client) { + client.toggleReconnect(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } } }, app.handleSuccess)); } }); - if (status != null && downloads != null) - onDataReceived(); - - registerForContextMenu(v.findViewById(android.R.id.list)); - - return v; - } - - @Override - public void onActivityCreated(Bundle savedInstanceState) { - super.onActivityCreated(savedInstanceState); - setListAdapter(adp); - } - - @Override - public void onStart() { - super.onStart(); - onSelected(); - } - - @Override - public void onCreateContextMenu(ContextMenu menu, View v, - ContextMenuInfo menuInfo) { - MenuInflater inflater = getActivity().getMenuInflater(); - inflater.inflate(R.menu.overview_context_menu, menu); - menu.setHeaderTitle(R.string.choose_action); - } - - @Override - public boolean onContextItemSelected(MenuItem item) { - - if (!app.isCurrentTab(pos)) - return false; - - AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item - .getMenuInfo(); - final int id = menuInfo.position; - final DownloadInfo info = downloads.get(id); - switch (item.getItemId()) { - case R.id.abort: - - app.addTask(new GuiTask(new Runnable() { - - public void run() { - client = app.getClient(); - ArrayList<Integer> fids = new ArrayList<Integer>(); - fids.add(info.fid); - client.stopDownloads(fids); - } - }, new Runnable() { - - public void run() { - refresh(); - } - })); - return true; - - default: - return super.onContextItemSelected(item); - } - - } - - @Override - public void onSelected() { - startUpdate(); - } - - @Override - public void onDeselected() { - stopUpdate(); - } - - private void startUpdate() { - // already update running - if (update) - return; - try { - interval = Integer.parseInt(app.prefs - .getString("refresh_rate", "5")); - } catch (NumberFormatException e) { - // somehow contains illegal value - interval = 5; - } - - update = true; - mHandler.post(mUpdateTimeTask); - } - - private void stopUpdate() { - update = false; - mHandler.removeCallbacks(mUpdateTimeTask); - } - - /** - * Called when Status data received - */ - protected void onDataReceived() { - OverviewAdapter adapter = (OverviewAdapter) getListAdapter(); - - adapter.setDownloads(downloads); - - statusServer.setText(app.verboseBool(status.download)); - reconnect.setText(app.verboseBool(status.reconnect)); - speed.setText(Utils.formatSize(status.speed) + "/s"); - active.setText(String.format("%d / %d", status.active, status.total)); - - if (captcha != null && app.prefs.getBoolean("pull_captcha", true) - && captcha.resultType != null // string null bug - && captcha.resultType.equals("textual") - && lastCaptcha != captcha.tid) { - showDialog(); - } - - } - - public void refresh() { - if (!app.hasConnection()) - return; - - GuiTask task = new GuiTask(runUpdate, mUpdateResults); - task.setCritical(cancelUpdate); - - app.addTask(task); - } - - private void showDialog() { - - if (dialogOpen || captcha == null) - return; - - CaptchaDialog dialog = CaptchaDialog.newInstance(captcha); - lastCaptcha = captcha.tid; - - Log.d("pyLoad", "Got Captcha Task"); - - dialog.setOnDismissListener(this); - - dialogOpen = true; - try { - dialog.show(getFragmentManager(), CaptchaDialog.class.getName()); - } catch (IllegalStateException e) { - dialogOpen = false; - // seems to appear when overview is already closed - Log.e("pyLoad", "Dialog state error", e); - } catch (NullPointerException e) { - dialogOpen = false; - // something is null, but why? - Log.e("pyLoad", "Dialog null pointer error", e); - } - - } - - public void onDismiss(DialogInterface arg0) { - captcha = null; - dialogOpen = false; - } - - @Override - public void setPosition(int pos) { - this.pos = pos; - } + if (status != null && downloads != null) + onDataReceived(); + + registerForContextMenu(v.findViewById(android.R.id.list)); + + return v; + } + + @Override + public void onActivityCreated(Bundle savedInstanceState) { + super.onActivityCreated(savedInstanceState); + setListAdapter(adp); + } + + @Override + public void onStart() { + super.onStart(); + onSelected(); + } + + @Override + public void onCreateContextMenu(ContextMenu menu, View v, + ContextMenuInfo menuInfo) { + MenuInflater inflater = getActivity().getMenuInflater(); + inflater.inflate(R.menu.overview_context_menu, menu); + menu.setHeaderTitle(R.string.choose_action); + } + + @Override + public boolean onContextItemSelected(MenuItem item) { + + if (!app.isCurrentTab(pos)) + return false; + + AdapterContextMenuInfo menuInfo = (AdapterContextMenuInfo) item + .getMenuInfo(); + final int id = menuInfo.position; + final DownloadInfo info = downloads.get(id); + switch (item.getItemId()) { + case R.id.abort: + + app.addTask(new GuiTask(new Runnable() { + + public void run() { + try { + client = app.getClient(); + ArrayList<Integer> fids = new ArrayList<Integer>(); + fids.add(info.fid); + synchronized (client) { + client.stopDownloads(fids); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } + }, new Runnable() { + + public void run() { + refresh(); + } + })); + return true; + + default: + return super.onContextItemSelected(item); + } + + } + + @Override + public void onSelected() { + startUpdate(); + } + + @Override + public void onDeselected() { + stopUpdate(); + } + + private void startUpdate() { + // already update running + if (update) + return; + try { + interval = Integer.parseInt(app.prefs + .getString("refresh_rate", "5")); + } catch (NumberFormatException e) { + // somehow contains illegal value + interval = 5; + } + + update = true; + mHandler.post(mUpdateTimeTask); + } + + private void stopUpdate() { + update = false; + mHandler.removeCallbacks(mUpdateTimeTask); + } + + /** + * Called when Status data received + */ + protected void onDataReceived() { + OverviewAdapter adapter = (OverviewAdapter) getListAdapter(); + + adapter.setDownloads(downloads); + + statusServer.setText(app.verboseBool(status.download)); + reconnect.setText(app.verboseBool(status.reconnect)); + speed.setText(Utils.formatSize(status.speed) + "/s"); + active.setText(String.format("%d / %d", status.active, status.total)); + + if (captcha != null && app.prefs.getBoolean("pull_captcha", true) + && captcha.resultType != null // string null bug + && captcha.resultType.equals("textual") + && lastCaptcha != captcha.tid) { + showDialog(); + } + + } + + public void refresh() { + if (!app.hasConnection()) + return; + + GuiTask task = new GuiTask(runUpdate, mUpdateResults); + task.setCritical(cancelUpdate); + + app.addTask(task); + } + + private void showDialog() { + + if (dialogOpen || captcha == null) + return; + + CaptchaDialog dialog = CaptchaDialog.newInstance(captcha); + lastCaptcha = captcha.tid; + + Log.d("pyLoad", "Got Captcha Task"); + + dialog.setOnDismissListener(this); + + dialogOpen = true; + try { + dialog.show(getFragmentManager(), CaptchaDialog.class.getName()); + } catch (IllegalStateException e) { + dialogOpen = false; + // seems to appear when overview is already closed + Log.e("pyLoad", "Dialog state error", e); + } catch (NullPointerException e) { + dialogOpen = false; + // something is null, but why? + Log.e("pyLoad", "Dialog null pointer error", e); + } + + } + + public void onDismiss(DialogInterface arg0) { + captcha = null; + dialogOpen = false; + } + + @Override + public void setPosition(int pos) { + this.pos = pos; + } } /** * Renders the single ListView items - * + * * @author RaNaN - * */ class OverviewAdapter extends BaseAdapter { - static class ViewHolder { - private TextView name; - private ProgressBar progress; - private TextView size; - private TextView percent; - private TextView size_done; - private TextView speed; - private TextView eta; - } - - private final pyLoadApp app; - private List<DownloadInfo> downloads; - private final int rowResID; - private final LayoutInflater layoutInflater; - - public OverviewAdapter(final pyLoadApp app, final int rowResID, - List<DownloadInfo> downloads) { - this.app = app; - this.rowResID = rowResID; - this.downloads = downloads; - - layoutInflater = (LayoutInflater) app - .getSystemService(Context.LAYOUT_INFLATER_SERVICE); - } - - public void setDownloads(List<DownloadInfo> downloads) { - this.downloads = downloads; - notifyDataSetChanged(); - } - - public int getCount() { - return downloads.size(); - } - - public Object getItem(int id) { - return downloads.get(id); - } - - public long getItemId(int pos) { - return pos; - } - - public View getView(int position, View convertView, ViewGroup parent) { - DownloadInfo info = downloads.get(position); - if (convertView == null) { - convertView = layoutInflater.inflate(rowResID, null); - ViewHolder holder = new ViewHolder(); - holder.name = (TextView) convertView.findViewById(R.id.name); - holder.progress = (ProgressBar) convertView - .findViewById(R.id.progress); - holder.size = (TextView) convertView.findViewById(R.id.size); - holder.speed = (TextView) convertView.findViewById(R.id.speed); - holder.size_done = (TextView) convertView - .findViewById(R.id.size_done); - holder.eta = (TextView) convertView.findViewById(R.id.eta); - holder.percent = (TextView) convertView.findViewById(R.id.percent); - convertView.setTag(holder); - } - - ViewHolder holder = (ViewHolder) convertView.getTag(); - - - // name is null sometimes somehow - if (info.name != null && !info.name.equals(holder.name.getText())) { - holder.name.setText(info.name); - } - - holder.progress.setProgress(info.percent); - - if (info.status == DownloadStatus.Downloading) { - holder.size.setText(Utils.formatSize(info.size)); - holder.percent.setText(info.percent + "%"); - holder.size_done.setText(Utils.formatSize(info.size - info.bleft)); - - holder.speed.setText(Utils.formatSize(info.speed) + "/s"); - holder.eta.setText(info.format_eta); - - } else if (info.status == DownloadStatus.Waiting) { - holder.size.setText(R.string.lambda); - holder.percent.setText(R.string.lambda); - holder.size_done.setText(R.string.lambda); - - holder.speed.setText(info.statusmsg); - holder.eta.setText(info.format_wait); - - } else { - holder.size.setText(R.string.lambda); - holder.percent.setText(R.string.lambda); - holder.size_done.setText(R.string.lambda); - - holder.speed.setText(info.statusmsg); - holder.eta.setText(R.string.lambda); - } - - return convertView; - - } - - public boolean hasStableIds() { - return false; - } + private final pyLoadApp app; + private final int rowResID; + private final LayoutInflater layoutInflater; + private List<DownloadInfo> downloads; + + public OverviewAdapter(final pyLoadApp app, final int rowResID, + List<DownloadInfo> downloads) { + this.app = app; + this.rowResID = rowResID; + this.downloads = downloads; + + layoutInflater = (LayoutInflater) app + .getSystemService(Context.LAYOUT_INFLATER_SERVICE); + } + + public void setDownloads(List<DownloadInfo> downloads) { + this.downloads = downloads; + notifyDataSetChanged(); + } + + public int getCount() { + return downloads.size(); + } + + public Object getItem(int id) { + return downloads.get(id); + } + + public long getItemId(int pos) { + return pos; + } + + public View getView(int position, View convertView, ViewGroup parent) { + DownloadInfo info = downloads.get(position); + if (convertView == null) { + convertView = layoutInflater.inflate(rowResID, null); + ViewHolder holder = new ViewHolder(); + holder.name = (TextView) convertView.findViewById(R.id.name); + holder.progress = (ProgressBar) convertView + .findViewById(R.id.progress); + holder.size = (TextView) convertView.findViewById(R.id.size); + holder.speed = (TextView) convertView.findViewById(R.id.speed); + holder.size_done = (TextView) convertView + .findViewById(R.id.size_done); + holder.eta = (TextView) convertView.findViewById(R.id.eta); + holder.percent = (TextView) convertView.findViewById(R.id.percent); + convertView.setTag(holder); + } + + ViewHolder holder = (ViewHolder) convertView.getTag(); + + + // name is null sometimes somehow + if (info.name != null && !info.name.equals(holder.name.getText())) { + holder.name.setText(info.name); + } + + holder.progress.setProgress(info.percent); + + if (info.status == DownloadStatus.Downloading) { + holder.size.setText(Utils.formatSize(info.size)); + holder.percent.setText(info.percent + "%"); + holder.size_done.setText(Utils.formatSize(info.size - info.bleft)); + + holder.speed.setText(Utils.formatSize(info.speed) + "/s"); + holder.eta.setText(info.format_eta); + + } else if (info.status == DownloadStatus.Waiting) { + holder.size.setText(R.string.lambda); + holder.percent.setText(R.string.lambda); + holder.size_done.setText(R.string.lambda); + + holder.speed.setText(info.statusmsg); + holder.eta.setText(info.format_wait); + + } else { + holder.size.setText(R.string.lambda); + holder.percent.setText(R.string.lambda); + holder.size_done.setText(R.string.lambda); + + holder.speed.setText(info.statusmsg); + holder.eta.setText(R.string.lambda); + } + + return convertView; + + } + + public boolean hasStableIds() { + return false; + } + + static class ViewHolder { + private TextView name; + private ProgressBar progress; + private TextView size; + private TextView percent; + private TextView size_done; + private TextView speed; + private TextView eta; + } } diff --git a/app/src/main/java/org/pyload/android/client/fragments/SettingsFragment.java b/app/src/main/java/org/pyload/android/client/fragments/SettingsFragment.java index 8c428c0..76bf63e 100644 --- a/app/src/main/java/org/pyload/android/client/fragments/SettingsFragment.java +++ b/app/src/main/java/org/pyload/android/client/fragments/SettingsFragment.java @@ -4,6 +4,7 @@ import java.util.Map; import java.util.Map.Entry; +import org.apache.thrift.TException; import org.pyload.android.client.R; import org.pyload.android.client.pyLoadApp; import org.pyload.android.client.module.GuiTask; @@ -16,6 +17,7 @@ import android.support.v4.app.Fragment; import android.support.v4.app.FragmentTransaction; import android.support.v4.app.ListFragment; +import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; @@ -91,9 +93,15 @@ private void update() { GuiTask task = new GuiTask(new Runnable() { public void run() { + try{ Client client = app.getClient(); - generalData = client.getConfig(); - pluginData = client.getPluginConfig(); + synchronized (client) { + generalData = client.getConfig(); + pluginData = client.getPluginConfig(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } } }, mUpdateResults); diff --git a/app/src/main/java/org/pyload/android/client/pyLoad.java b/app/src/main/java/org/pyload/android/client/pyLoad.java index 443d72d..a3e91e3 100644 --- a/app/src/main/java/org/pyload/android/client/pyLoad.java +++ b/app/src/main/java/org/pyload/android/client/pyLoad.java @@ -1,14 +1,27 @@ package org.pyload.android.client; -import java.io.File; -import java.io.FileInputStream; -import java.nio.ByteBuffer; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.Locale; - +import android.app.AlarmManager; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; import android.content.res.Configuration; -import android.view.*; +import android.content.res.Resources; +import android.net.ConnectivityManager; +import android.net.Uri; +import android.os.Build; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.support.v4.view.MenuItemCompat; +import android.util.Log; +import android.view.Menu; +import android.view.MenuInflater; +import android.view.MenuItem; +import android.widget.TabHost; +import android.widget.Toast; + +import org.apache.thrift.TException; import org.pyload.android.client.components.FragmentTabsPager; import org.pyload.android.client.dialogs.AccountDialog; import org.pyload.android.client.fragments.CollectorFragment; @@ -16,31 +29,34 @@ import org.pyload.android.client.fragments.QueueFragment; import org.pyload.android.client.module.Eula; import org.pyload.android.client.module.GuiTask; +import org.pyload.android.client.service.CheckCaptchaService; import org.pyload.thrift.Destination; import org.pyload.thrift.PackageDoesNotExists; import org.pyload.thrift.Pyload.Client; -import android.content.Context; -import android.content.Intent; -import android.content.res.Resources; -import android.net.ConnectivityManager; -import android.net.Uri; -import android.os.Bundle; -import android.preference.PreferenceManager; -import android.util.Log; -import android.widget.TabHost; -import android.support.v4.view.MenuItemCompat; +import java.io.File; +import java.io.FileInputStream; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Locale; public class pyLoad extends FragmentTabsPager { - private pyLoadApp app; + private pyLoadApp app; // keep reference to set indeterminateProgress private MenuItem refreshItem; - /** Called when the activity is first created. */ + // AlarmManager and PendingIntent for CheckCaptchaService + private AlarmManager alarmManager; + private PendingIntent checkCaptchaIntent; + + /** + * Called when the activity is first created. + */ - public void onCreate(Bundle savedInstanceState) { + public void onCreate(Bundle savedInstanceState) { Log.d("pyLoad", "Starting pyLoad App"); @@ -48,49 +64,49 @@ public void onCreate(Bundle savedInstanceState) { app.prefs = PreferenceManager.getDefaultSharedPreferences(this); initLocale(); - super.onCreate(savedInstanceState); - Eula.show(this); - - app.cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); - app.init(this); - - Resources res = getResources(); // Resource object to get Drawables - TabHost.TabSpec spec; // Resusable TabSpec for each tab - String title; - - int tab_pyload, tab_queue, tab_collector; - if (app.prefs.getBoolean("invert_tabs", false)) { - tab_pyload = R.drawable.ic_tab_pyload_inverted; - tab_queue = R.drawable.ic_tab_queue_inverted; - tab_collector = R.drawable.ic_tab_collector_inverted; - } else { - tab_pyload = R.drawable.ic_tab_pyload; - tab_queue = R.drawable.ic_tab_queue; - tab_collector = R.drawable.ic_tab_collector; - } - - title = getString(R.string.overview); - spec = mTabHost.newTabSpec(title).setIndicator(title, - res.getDrawable(tab_pyload)); - mTabsAdapter.addTab(spec, OverviewFragment.class, null); - - title = getString(R.string.queue); - spec = mTabHost.newTabSpec(title).setIndicator(title, - res.getDrawable(tab_queue)); - mTabsAdapter.addTab(spec, QueueFragment.class, null); - - title = getString(R.string.collector); - spec = mTabHost.newTabSpec(title).setIndicator(title, - res.getDrawable(tab_collector)); - mTabsAdapter.addTab(spec, CollectorFragment.class, null); - } - - @Override - protected void onStart() { - super.onStart(); - Intent intent = getIntent(); + super.onCreate(savedInstanceState); + Eula.show(this); + + app.cm = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE); + app.init(this); + + Resources res = getResources(); // Resource object to get Drawables + TabHost.TabSpec spec; // Resusable TabSpec for each tab + String title; + + int tab_pyload, tab_queue, tab_collector; + if (app.prefs.getBoolean("invert_tabs", false)) { + tab_pyload = R.drawable.ic_tab_pyload_inverted; + tab_queue = R.drawable.ic_tab_queue_inverted; + tab_collector = R.drawable.ic_tab_collector_inverted; + } else { + tab_pyload = R.drawable.ic_tab_pyload; + tab_queue = R.drawable.ic_tab_queue; + tab_collector = R.drawable.ic_tab_collector; + } + + title = getString(R.string.overview); + spec = mTabHost.newTabSpec(title).setIndicator(title, + res.getDrawable(tab_pyload)); + mTabsAdapter.addTab(spec, OverviewFragment.class, null); + + title = getString(R.string.queue); + spec = mTabHost.newTabSpec(title).setIndicator(title, + res.getDrawable(tab_queue)); + mTabsAdapter.addTab(spec, QueueFragment.class, null); + + title = getString(R.string.collector); + spec = mTabHost.newTabSpec(title).setIndicator(title, + res.getDrawable(tab_collector)); + mTabsAdapter.addTab(spec, CollectorFragment.class, null); + } + + @Override + protected void onStart() { + super.onStart(); + Intent intent = getIntent(); String action = intent.getAction(); - Uri data = intent.getData(); + Uri data = intent.getData(); // we got a SHARE intent if (Intent.ACTION_SEND.equals(action)) { @@ -100,7 +116,7 @@ protected void onStart() { startActivityForResult(addURL, AddLinksActivity.NEW_PACKAGE); intent.setAction(Intent.ACTION_MAIN); - // we got a VIEW intent + // we got a VIEW intent } else if (Intent.ACTION_VIEW.equals(action) && data != null) { if (intent.getScheme().startsWith("http") || intent.getScheme().contains("ftp")) { Intent addURL = new Intent(app, AddLinksActivity.class); @@ -113,22 +129,44 @@ protected void onStart() { } intent.setData(null); } - } - - @Override - protected void onResume() { - super.onResume(); - app.refreshTab(); - } - - @Override - protected void onPause() { - super.onPause(); - app.clearTasks(); - } - - @Override - public boolean onCreateOptionsMenu(Menu menu) { + + // get AlarmManager and create PendingIntent for CheckCaptchaService + alarmManager = (AlarmManager) getSystemService(ALARM_SERVICE); + checkCaptchaIntent = PendingIntent.getService(this.getApplication(), 0, + new Intent(this.getApplication(), CheckCaptchaService.class), 0); + app.notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); + } + + @Override + protected void onResume() { + super.onResume(); + app.refreshTab(); + alarmManager.cancel(checkCaptchaIntent); + app.notificationManager.cancel(CheckCaptchaService.NOTIFICATION_ID); + } + + @Override + protected void onPause() { + super.onPause(); + app.clearTasks(); + // create background service to check for captchas + if (app.prefs.getBoolean(Preferences.CHECK_CAPTCHA_SERVICE_ENABLE, true)) { + int interval = 5; + try { + interval = Integer.parseInt(app.prefs + .getString("refresh_rate", "5")); + } catch (NumberFormatException e) { + interval = 5; + } + Toast.makeText(this, "Checking for Captcha every " + interval + "s", Toast.LENGTH_SHORT).show(); + interval *= 1000; + alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, System.currentTimeMillis() + interval, + interval, checkCaptchaIntent); + } + } + + @Override + public boolean onCreateOptionsMenu(Menu menu) { MenuInflater inflater = getMenuInflater(); inflater.inflate(R.menu.menu, menu); refreshItem = menu.findItem(R.id.refresh); @@ -137,145 +175,171 @@ public boolean onCreateOptionsMenu(Menu menu) { MenuItemCompat.setShowAsAction(menu.findItem(R.id.add_links), MenuItemCompat.SHOW_AS_ACTION_IF_ROOM); - return true; - } - - @Override - public boolean onOptionsItemSelected(MenuItem item) { - switch (item.getItemId()) { - case R.id.add_links: - startActivityForResult(new Intent(app, AddLinksActivity.class), - AddLinksActivity.NEW_PACKAGE); + menu.findItem(R.id.ic_menu_check_captcha).setChecked( + app.prefs.getBoolean(Preferences.CHECK_CAPTCHA_SERVICE_ENABLE, true)); - return true; - - case R.id.refresh: - app.resetClient(); - app.refreshTab(); - - return true; - - case R.id.settings: - Intent settingsActivity = new Intent(app, Preferences.class); - startActivity(settingsActivity); - - return true; + return true; + } - case R.id.show_accounts: - AccountDialog accountsList = new AccountDialog(); - accountsList.show(getSupportFragmentManager(), "accountsDialog"); + @Override + public boolean onOptionsItemSelected(MenuItem item) { + switch (item.getItemId()) { + case R.id.add_links: + startActivityForResult(new Intent(app, AddLinksActivity.class), + AddLinksActivity.NEW_PACKAGE); + + return true; + + case R.id.refresh: + app.resetClient(); + app.refreshTab(); + + return true; + + case R.id.settings: + Intent settingsActivity = new Intent(app, Preferences.class); + startActivity(settingsActivity); + + return true; + + case R.id.show_accounts: + AccountDialog accountsList = new AccountDialog(); + accountsList.show(getSupportFragmentManager(), "accountsDialog"); + + return true; + + case R.id.remote_settings: + Intent serverConfigActivity = new Intent(app, RemoteSettings.class); + startActivity(serverConfigActivity); + + return true; + + case R.id.restart_failed: + app.addTask(new GuiTask(new Runnable() { + public void run() { + Client client = null; + try { + client = app.getClient(); + synchronized (client) { + client.restartFailed(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + + } + }, app.handleSuccess)); + + return true; + case R.id.ic_menu_check_captcha: + SharedPreferences.Editor prefEdit = app.prefs.edit(); + Log.d("pyLoad", "CheckCaptcha: " + item.isChecked()); + prefEdit.putBoolean(Preferences.CHECK_CAPTCHA_SERVICE_ENABLE, !item.isChecked()); + if (Build.VERSION.SDK_INT >= 7) + prefEdit.apply(); + else + prefEdit.commit(); + item.setChecked(!item.isChecked()); + return true; + + default: + return super.onOptionsItemSelected(item); + } + } - return true; + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + + switch (requestCode) { + case AddLinksActivity.NEW_PACKAGE: + switch (resultCode) { + case RESULT_OK: + final String name = data.getStringExtra("name"); + final String[] link_array = data.getStringExtra("links").trim() + .split("\n"); + final Destination dest; + final String filepath = data.getStringExtra("filepath"); + final String filename = data.getStringExtra("filename"); + + if (data.getIntExtra("dest", 0) == 0) + dest = Destination.Queue; + else + dest = Destination.Collector; + + final ArrayList<String> links = new ArrayList<String>(); + for (String link_row : link_array) + for (String link : link_row.trim().split(" ")) + if (!link.equals("")) + links.add(link); + + final String password = data.getStringExtra("password"); + + app.addTask(new GuiTask(new Runnable() { + + public void run() { + Client client = null; + try { + client = app.getClient(); + synchronized (client) { + if (links.size() > 0) { + int pid = client.addPackage(name, links, dest); + + if (password != null && !password.equals("")) { + + HashMap<String, String> opts = new HashMap<String, String>(); + opts.put("password", password); + + try { + client.setPackageData(pid, opts); + } catch (PackageDoesNotExists e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + } + if (filename != null && !filepath.equals("")) { + + File file = new File(filepath); + try { + if (file.length() > (1 << 20)) + throw new Exception("File size to large"); + FileInputStream is = new FileInputStream(file); + ByteBuffer buffer = ByteBuffer + .allocate((int) file.length()); + + while (is.getChannel().read(buffer) > 0) ; + + buffer.rewind(); + is.close(); + client.uploadContainer(filename, buffer); + + } catch (Throwable e) { + Log.e("pyLoad", "Error when uploading file", e); + } + } + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } + }, app.handleSuccess)); + break; + default: + break; + } + break; - case R.id.remote_settings: - Intent serverConfigActivity = new Intent(app, RemoteSettings.class); - startActivity(serverConfigActivity); + default: + super.onActivityResult(requestCode, resultCode, data); + } - return true; + } - case R.id.restart_failed: - app.addTask(new GuiTask(new Runnable() { - public void run() { - Client client = app.getClient(); - client.restartFailed(); - } - }, app.handleSuccess)); - - return true; - - default: - return super.onOptionsItemSelected(item); - } - } - - @Override - protected void onActivityResult(int requestCode, int resultCode, Intent data) { - - switch (requestCode) { - case AddLinksActivity.NEW_PACKAGE: - switch (resultCode) { - case RESULT_OK: - final String name = data.getStringExtra("name"); - final String[] link_array = data.getStringExtra("links").trim() - .split("\n"); - final Destination dest; - final String filepath = data.getStringExtra("filepath"); - final String filename = data.getStringExtra("filename"); - - if (data.getIntExtra("dest", 0) == 0) - dest = Destination.Queue; - else - dest = Destination.Collector; - - final ArrayList<String> links = new ArrayList<String>(); - for (String link_row : link_array) - for (String link : link_row.trim().split(" ")) - if (!link.equals("")) - links.add(link); - - final String password = data.getStringExtra("password"); - - app.addTask(new GuiTask(new Runnable() { - - public void run() { - Client client = app.getClient(); - - if (links.size() > 0) { - int pid = client.addPackage(name, links, dest); - - if (password != null && !password.equals("")) { - - HashMap<String, String> opts = new HashMap<String, String>(); - opts.put("password", password); - - try { - client.setPackageData(pid, opts); - } catch (PackageDoesNotExists e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } - } - } - if (filename != null && !filepath.equals("")) { - - File file = new File(filepath); - try { - if (file.length() > (1 << 20)) - throw new Exception("File size to large"); - FileInputStream is = new FileInputStream(file); - ByteBuffer buffer = ByteBuffer - .allocate((int) file.length()); - - while (is.getChannel().read(buffer) > 0); - - buffer.rewind(); - is.close(); - client.uploadContainer(filename, buffer); - - } catch (Throwable e) { - Log.e("pyLoad", "Error when uploading file", e); - } - } - - } - }, app.handleSuccess)); - break; - default: - break; - } - break; - - default: - super.onActivityResult(requestCode, resultCode, data); - } - - } - - @Override - protected void onNewIntent(Intent intent) { - Log.d("pyLoad", "got Intent"); - super.onNewIntent(intent); - } + @Override + protected void onNewIntent(Intent intent) { + Log.d("pyLoad", "got Intent"); + super.onNewIntent(intent); + } /** * Sets the locale defined in config. @@ -296,18 +360,24 @@ private void initLocale() { getResources().getDisplayMetrics()); } - public void setCaptchaResult(final short tid, final String result) { - app.addTask(new GuiTask(new Runnable() { - - public void run() { - Client client = app.getClient(); - Log.d("pyLoad", "Send Captcha result: " + tid + " " + result); - client.setCaptchaResult(tid, result); - - } - })); + public void setCaptchaResult(final short tid, final String result) { + app.addTask(new GuiTask(new Runnable() { + + public void run() { + Client client = null; + try { + client = app.getClient(); + Log.d("pyLoad", "Send Captcha result: " + tid + " " + result); + synchronized (client) { + client.setCaptchaResult(tid, result); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + } + })); - } + } public MenuItem getRefreshItem() { return refreshItem; diff --git a/app/src/main/java/org/pyload/android/client/pyLoadApp.java b/app/src/main/java/org/pyload/android/client/pyLoadApp.java index aca8ec9..52d16cf 100644 --- a/app/src/main/java/org/pyload/android/client/pyLoadApp.java +++ b/app/src/main/java/org/pyload/android/client/pyLoadApp.java @@ -13,10 +13,12 @@ import javax.net.ssl.*; import android.annotation.TargetApi; +import android.app.NotificationManager; import android.content.Context; import android.view.LayoutInflater; import android.view.MenuItem; import android.view.View; + import org.apache.http.conn.ssl.BrowserCompatHostnameVerifier; import org.apache.http.conn.ssl.X509HostnameVerifier; import org.apache.thrift.TException; @@ -45,254 +47,267 @@ public class pyLoadApp extends Application { - private Client client; + private Client client; - // setted by main activity - private TaskQueue taskQueue; - private Throwable lastException; - public SharedPreferences prefs; - public ConnectivityManager cm; + // setted by main activity + private TaskQueue taskQueue; + private Throwable lastException; + public SharedPreferences prefs; + public ConnectivityManager cm; - private pyLoad main; + /** + * NotificationManager used by CheckCaptchaService + */ + public NotificationManager notificationManager; - private static final String[] clientVersion = {"0.4.8", "0.4.9"}; + private pyLoad main; - public void init(pyLoad main) { - this.main = main; + private static final String[] clientVersion = {"0.4.8", "0.4.9"}; - HashMap<Throwable, Runnable> map = new HashMap<Throwable, Runnable>(); - map.put(new TException(), handleException); - map.put(new WrongLogin(), handleException); - map.put(new TTransportException(), handleException); - map.put(new WrongServer(), handleException); + public void init(pyLoad main) { + this.main = main; + + HashMap<Throwable, Runnable> map = new HashMap<Throwable, Runnable>(); + map.put(new TException(), handleException); + map.put(new WrongLogin(), handleException); + map.put(new TTransportException(), handleException); + map.put(new WrongServer(), handleException); taskQueue = new TaskQueue(this, new Handler(), map); - startTaskQueue(); - } - - public String verboseBool(boolean state) { - if (state) - return getString(R.string.on); - else - return getString(R.string.off); - } - - private boolean login() throws TException { - - // replace protocol, some user also enter it - String host = prefs.getString("host", "10.0.2.2").replaceFirst("^[a-zA-z]+://", ""); - int port = Integer.parseInt(prefs.getString("port", "7227")); - String username = prefs.getString("username", "User"); - String password = prefs.getString("password", "pwhere"); - - // TODO: better exception handling - TTransport trans; - try { - if (prefs.getBoolean("ssl", false)) { - SSLContext ctx; - TrustManager[] trustManagers; - try { - if (prefs.getBoolean("ssl_validate", true)) { - TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); - tmf.init((KeyStore) null); - trustManagers = tmf.getTrustManagers(); - } else { - trustManagers = new TrustManager[1]; - trustManagers[0] = new AllTrustManager(); - } - ctx = SSLContext.getInstance("TLS"); - ctx.init(null, trustManagers, null); - Log.d("pyLoad", "SSL Context created"); - } catch (NoSuchAlgorithmException e) { - throw new TException(e); - } catch (KeyStoreException e) { - throw new TException(e); - } catch (KeyManagementException e) { - throw new TException(e); - } - // timeout 8000ms - trans = TSSLTransportFactory.createClient(ctx.getSocketFactory(), host, port, 8000); - if (prefs.getBoolean("ssl_validate", true)) { - X509HostnameVerifier verifier = new BrowserCompatHostnameVerifier(); - try { - verifier.verify(host, (SSLSocket) ((TSocket) trans).getSocket()); - } catch (IOException e) { - throw new TException(e); - } - // TODO: check OCSP/CRL - } - } else { - trans = new TSocket(host, port, 8000); - trans.open(); - } - } catch (TTransportException e) { - throw new TException(e); - } - - TProtocol iprot = new TBinaryProtocol(trans); - - client = new Client(iprot); - return client.login(username, password); - } - - public Client getClient() throws TException, WrongLogin { - - if (client == null) { - Log.d("pyLoad", "Creating new Client"); - boolean loggedin = login(); - if (!loggedin) { - client = null; - throw new WrongLogin(); - } - - String server = client.getServerVersion(); - boolean match = false; - - for (String version : clientVersion) - if(server.equals(version)) - match = true; - - if (!match) - throw new WrongServer(); - - } - return client; - } - - public void addTask(GuiTask task) { - taskQueue.addTask(task); - } - - public void startTaskQueue() { - taskQueue.start(); - } - - final public Runnable handleException = new Runnable() { - - public void run() { - onException(); - } - }; - - public void onException() { - client = null; + startTaskQueue(); + } + + public String verboseBool(boolean state) { + if (state) + return getString(R.string.on); + else + return getString(R.string.off); + } + + private boolean login() throws TException { + + // replace protocol, some user also enter it + String host = prefs.getString("host", "10.0.2.2").replaceFirst("^[a-zA-z]+://", ""); + int port = Integer.parseInt(prefs.getString("port", "7227")); + String username = prefs.getString("username", "User"); + String password = prefs.getString("password", "pwhere"); + + // TODO: better exception handling + TTransport trans; + try { + if (prefs.getBoolean("ssl", false)) { + SSLContext ctx; + TrustManager[] trustManagers; + try { + if (prefs.getBoolean("ssl_validate", true)) { + TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); + tmf.init((KeyStore) null); + trustManagers = tmf.getTrustManagers(); + } else { + trustManagers = new TrustManager[1]; + trustManagers[0] = new AllTrustManager(); + } + ctx = SSLContext.getInstance("TLS"); + ctx.init(null, trustManagers, null); + Log.d("pyLoad", "SSL Context created"); + } catch (NoSuchAlgorithmException e) { + throw new TException(e); + } catch (KeyStoreException e) { + throw new TException(e); + } catch (KeyManagementException e) { + throw new TException(e); + } + // timeout 8000ms + trans = TSSLTransportFactory.createClient(ctx.getSocketFactory(), host, port, 8000); + if (prefs.getBoolean("ssl_validate", true)) { + X509HostnameVerifier verifier = new BrowserCompatHostnameVerifier(); + try { + verifier.verify(host, (SSLSocket) ((TSocket) trans).getSocket()); + } catch (IOException e) { + throw new TException(e); + } + // TODO: check OCSP/CRL + } + } else { + trans = new TSocket(host, port, 8000); + trans.open(); + } + } catch (TTransportException e) { + throw new TException(e); + } + + TProtocol iprot = new TBinaryProtocol(trans); + + client = new Client(iprot); + return client.login(username, password); + } + + // syncronize access to only create one client + public synchronized Client getClient() throws TException, WrongLogin { + if (client == null) { + Log.d("pyLoad", "Creating new Client"); + boolean loggedin = login(); + if (!loggedin) { + client = null; + throw new WrongLogin(); + } + + String server = client.getServerVersion(); + boolean match = false; + for (String version : clientVersion) + if (server.equals(version)) + match = true; + if (!match) + throw new WrongServer(); + } else { + // check if the client is still connected + try { + client.getServerVersion(); + } catch (TException e) { + // set client to null to retry creating connection + client = null; + return getClient(); + } + } + + return client; + } + + public void addTask(GuiTask task) { + taskQueue.addTask(task); + } + + public void startTaskQueue() { + taskQueue.start(); + } + + final public Runnable handleException = new Runnable() { + + public void run() { + onException(); + } + }; + + public void onException() { + client = null; // The task queue will log an error with exception - if (lastException instanceof TTransportException) { - Toast t = Toast.makeText(this, R.string.lost_connection, - Toast.LENGTH_SHORT); - t.show(); - } else if (lastException instanceof WrongLogin) { - Toast t = Toast.makeText(this, R.string.bad_login, - Toast.LENGTH_SHORT); - t.show(); - } else if (lastException instanceof TException) { + if (lastException instanceof TTransportException) { + Toast t = Toast.makeText(this, R.string.lost_connection, + Toast.LENGTH_SHORT); + t.show(); + } else if (lastException instanceof WrongLogin) { + Toast t = Toast.makeText(this, R.string.bad_login, + Toast.LENGTH_SHORT); + t.show(); + } else if (lastException instanceof TException) { Throwable tr = findException(lastException); Toast t; if (tr instanceof SSLHandshakeException) t = Toast.makeText(this, R.string.certificate_error, Toast.LENGTH_SHORT); - else if(tr instanceof SocketTimeoutException) + else if (tr instanceof SocketTimeoutException) t = Toast.makeText(this, R.string.connect_timeout, Toast.LENGTH_SHORT); - else if(tr instanceof ConnectException) + else if (tr instanceof ConnectException) t = Toast.makeText(this, R.string.connect_error, Toast.LENGTH_SHORT); - else if(tr instanceof SocketException) + else if (tr instanceof SocketException) t = Toast.makeText(this, R.string.socket_error, Toast.LENGTH_SHORT); else - t = Toast.makeText(this, getString(R.string.no_connection)+ " " + tr.getMessage(), Toast.LENGTH_SHORT); - - t.show(); - } else if (lastException instanceof WrongServer) { - Toast t = Toast.makeText(this, String.format( - getString(R.string.old_server), clientVersion[clientVersion.length-1]), - Toast.LENGTH_SHORT); - t.show(); - } + t = Toast.makeText(this, getString(R.string.no_connection) + " " + tr.getMessage(), Toast.LENGTH_SHORT); + + t.show(); + } else if (lastException instanceof WrongServer) { + Toast t = Toast.makeText(this, String.format( + getString(R.string.old_server), clientVersion[clientVersion.length - 1]), + Toast.LENGTH_SHORT); + t.show(); + } - setProgress(false); - } + setProgress(false); + } /** * Retrieves first root exception on stack of several TExceptions. + * * @return the first exception not a TException or the last TException */ private Throwable findException(Throwable e) { // will not terminate when cycles occur, hopefully nobody cycle exception causes while (e instanceof TException) { - if (e.getCause() == null) break; - if (e.getCause() == e) break; // just to avoid loop - e = e.getCause(); + if (e.getCause() == null) break; + if (e.getCause() == e) break; // just to avoid loop + e = e.getCause(); } return e; } - final public Runnable handleSuccess = new Runnable() { - @Override - public void run() { - onSuccess(); - } - }; + final public Runnable handleSuccess = new Runnable() { + @Override + public void run() { + onSuccess(); + } + }; - public void onSuccess() { - Toast t = Toast.makeText(this, R.string.success, Toast.LENGTH_SHORT); - t.show(); + public void onSuccess() { + Toast t = Toast.makeText(this, R.string.success, Toast.LENGTH_SHORT); + t.show(); - refreshTab(); - } + refreshTab(); + } - public void refreshTab() { - Fragment frag = main.getCurrentFragment(); + public void refreshTab() { + Fragment frag = main.getCurrentFragment(); - Log.d("pyLoad", "Refreshing Tab: " + frag); + Log.d("pyLoad", "Refreshing Tab: " + frag); - if (frag != null) - ((TabHandler) frag).onSelected(); - } + if (frag != null) + ((TabHandler) frag).onSelected(); + } - public boolean isCurrentTab(int pos) { - return main.getCurrentTab() == pos; - } + public boolean isCurrentTab(int pos) { + return main.getCurrentTab() == pos; + } - public pyLoad getMain() { - return main; - } + public pyLoad getMain() { + return main; + } - public boolean hasConnection() { - NetworkInfo info = cm.getActiveNetworkInfo(); - // TODO investigate network states, info etc - return info != null; - } + public boolean hasConnection() { + NetworkInfo info = cm.getActiveNetworkInfo(); + // TODO investigate network states, info etc + return info != null; + } - public void clearTasks() { - taskQueue.clear(); - } + public void clearTasks() { + taskQueue.clear(); + } - public void setLastException(Throwable t) { - lastException = t; - } + public void setLastException(Throwable t) { + lastException = t; + } - public void resetClient() { - Log.d("pyLoad", "Client resetted"); - client = null; - } + public void resetClient() { + Log.d("pyLoad", "Client resetted"); + client = null; + } /** * Enables and disables the progress indicator. - * + * <p> * The indicator depends on the user's Android version. * pre-actionBar devices: Window.FEATURE_INDETERMINATE_PROGRESS * actionBar devices: set refreshAction's view to a progress wheel (Gmail like) * * @param state */ - public void setProgress(boolean state) { + public void setProgress(boolean state) { if (isActionBarAvailable()) { setIndeterminateProgress(main.getRefreshItem(), state); } else { setIndeterminateProgress(state); } - } + } @TargetApi(5) private void setIndeterminateProgress(boolean state) { diff --git a/app/src/main/java/org/pyload/android/client/service/CheckCaptchaService.java b/app/src/main/java/org/pyload/android/client/service/CheckCaptchaService.java new file mode 100644 index 0000000..47954a3 --- /dev/null +++ b/app/src/main/java/org/pyload/android/client/service/CheckCaptchaService.java @@ -0,0 +1,107 @@ +package org.pyload.android.client.service; + +import android.app.AlarmManager; +import android.app.Notification; +import android.app.NotificationManager; +import android.app.PendingIntent; +import android.app.Service; +import android.content.Intent; +import android.media.RingtoneManager; +import android.os.AsyncTask; +import android.os.Binder; +import android.os.IBinder; +import android.preference.PreferenceManager; +import android.support.v4.app.NotificationCompat; +import android.util.Log; + +import org.apache.thrift.TException; +import org.pyload.android.client.R; +import org.pyload.android.client.pyLoad; +import org.pyload.android.client.pyLoadApp; +import org.pyload.thrift.Pyload; + +/** + * Background Service checking for new captchas + */ +public class CheckCaptchaService extends Service { + + public static final int NOTIFICATION_ID = 1000; + + private pyLoadApp app; + private Pyload.Client client; + private final IBinder mBinder = new CheckCaptchaBinder(); + + @Override + public void onCreate() { + Log.d("pyLoad", "create CaptchaService"); + app = new pyLoadApp(); + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + Log.d("pyLoad", "Captcha check service"); + app.prefs = PreferenceManager.getDefaultSharedPreferences(this); + app.notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); + AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() { + @Override + protected Void doInBackground(Void... params) { + Log.d("pyLoad", "getting client in background"); + try { + client = app.getClient(); + boolean isCaptchaWaiting = false; + synchronized (client) { + isCaptchaWaiting = client.isCaptchaWaiting(); + } + if (isCaptchaWaiting) { + showNotification(); + } + } catch (TException e) { + Log.e("pyLoad", "Thrift problem", e); + } + return null; + } + }; + asyncTask.execute(); + return START_NOT_STICKY; + } + + @Override + public IBinder onBind(Intent intent) { + Log.d("pyLoad", "CaptchaBinder"); + return mBinder; + } + + public class CheckCaptchaBinder extends Binder { + CheckCaptchaService getService() { + return CheckCaptchaService.this; + } + } + + private void showNotification() { + // The PendingIntent to launch our activity if the user selects this notification + PendingIntent contentIntent; + contentIntent = PendingIntent.getActivity(this, 0, + new Intent(this, pyLoad.class), 0); + + // Build notification + NotificationCompat.Builder builder = new NotificationCompat.Builder(this) + .setSmallIcon(R.drawable.ic_launcher) + .setContentTitle(getText(R.string.app_name)) + .setContentText(getText(R.string.retrieve_captcha)) + .setContentIntent(contentIntent) + .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)); + Notification notification = builder.build(); + +// // Set the info for the views that show in the notification panel. +// notification.setLatestEventInfo(this, getText(R.string.app_name), +// getText(R.string.retrieve_captcha), contentIntent); + + // Send the notification. + app.notificationManager.notify(NOTIFICATION_ID, notification); + + // disable repeating background service, as we notify now + ((AlarmManager) getSystemService(ALARM_SERVICE)).cancel(PendingIntent.getService( + this.getApplication(), 0, new Intent(this.getApplication(), + CheckCaptchaService.class), 0)); + } +} \ No newline at end of file diff --git a/app/src/main/java/org/pyload/thrift/AccountInfo.java b/app/src/main/java/org/pyload/thrift/AccountInfo.java index 85cb343..e5dc924 100644 --- a/app/src/main/java/org/pyload/thrift/AccountInfo.java +++ b/app/src/main/java/org/pyload/thrift/AccountInfo.java @@ -1,1156 +1,1232 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class AccountInfo implements org.apache.thrift.TBase<AccountInfo, AccountInfo._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AccountInfo"); - - private static final org.apache.thrift.protocol.TField VALIDUNTIL_FIELD_DESC = new org.apache.thrift.protocol.TField("validuntil", org.apache.thrift.protocol.TType.I64, (short)1); - private static final org.apache.thrift.protocol.TField LOGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("login", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField OPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("options", org.apache.thrift.protocol.TType.MAP, (short)3); - private static final org.apache.thrift.protocol.TField VALID_FIELD_DESC = new org.apache.thrift.protocol.TField("valid", org.apache.thrift.protocol.TType.BOOL, (short)4); - private static final org.apache.thrift.protocol.TField TRAFFICLEFT_FIELD_DESC = new org.apache.thrift.protocol.TField("trafficleft", org.apache.thrift.protocol.TType.I64, (short)5); - private static final org.apache.thrift.protocol.TField MAXTRAFFIC_FIELD_DESC = new org.apache.thrift.protocol.TField("maxtraffic", org.apache.thrift.protocol.TType.I64, (short)6); - private static final org.apache.thrift.protocol.TField PREMIUM_FIELD_DESC = new org.apache.thrift.protocol.TField("premium", org.apache.thrift.protocol.TType.BOOL, (short)7); - private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short)8); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new AccountInfoStandardSchemeFactory()); - schemes.put(TupleScheme.class, new AccountInfoTupleSchemeFactory()); - } - - public long validuntil; // required - public String login; // required - public Map<String,List<String>> options; // required - public boolean valid; // required - public long trafficleft; // required - public long maxtraffic; // required - public boolean premium; // required - public String type; // 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 { - VALIDUNTIL((short)1, "validuntil"), - LOGIN((short)2, "login"), - OPTIONS((short)3, "options"), - VALID((short)4, "valid"), - TRAFFICLEFT((short)5, "trafficleft"), - MAXTRAFFIC((short)6, "maxtraffic"), - PREMIUM((short)7, "premium"), - TYPE((short)8, "type"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class AccountInfo implements org.apache.thrift.TBase<AccountInfo, AccountInfo._Fields>, java.io.Serializable, Cloneable, Comparable<AccountInfo>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("AccountInfo"); + + private static final org.apache.thrift.protocol.TField VALIDUNTIL_FIELD_DESC = new org.apache.thrift.protocol.TField("validuntil", org.apache.thrift.protocol.TType.I64, (short) 1); + private static final org.apache.thrift.protocol.TField LOGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("login", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField OPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("options", org.apache.thrift.protocol.TType.MAP, (short) 3); + private static final org.apache.thrift.protocol.TField VALID_FIELD_DESC = new org.apache.thrift.protocol.TField("valid", org.apache.thrift.protocol.TType.BOOL, (short) 4); + private static final org.apache.thrift.protocol.TField TRAFFICLEFT_FIELD_DESC = new org.apache.thrift.protocol.TField("trafficleft", org.apache.thrift.protocol.TType.I64, (short) 5); + private static final org.apache.thrift.protocol.TField MAXTRAFFIC_FIELD_DESC = new org.apache.thrift.protocol.TField("maxtraffic", org.apache.thrift.protocol.TType.I64, (short) 6); + private static final org.apache.thrift.protocol.TField PREMIUM_FIELD_DESC = new org.apache.thrift.protocol.TField("premium", org.apache.thrift.protocol.TType.BOOL, (short) 7); + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short) 8); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new AccountInfoStandardSchemeFactory()); + schemes.put(TupleScheme.class, new AccountInfoTupleSchemeFactory()); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // VALIDUNTIL - return VALIDUNTIL; - case 2: // LOGIN - return LOGIN; - case 3: // OPTIONS - return OPTIONS; - case 4: // VALID - return VALID; - case 5: // TRAFFICLEFT - return TRAFFICLEFT; - case 6: // MAXTRAFFIC - return MAXTRAFFIC; - case 7: // PREMIUM - return PREMIUM; - case 8: // TYPE - return TYPE; - default: - return null; - } + public long validuntil; // required + public String login; // required + public Map<String, List<String>> options; // required + public boolean valid; // required + public long trafficleft; // required + public long maxtraffic; // required + public boolean premium; // required + public String type; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeLong(validuntil); + out.writeString(login); + out.writeMap(options); + out.writeInt(valid ? 1 : 0); + out.writeLong(trafficleft); + out.writeLong(maxtraffic); + out.writeInt(premium ? 1 : 0); + out.writeString(type); } - /** - * 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; + @Override + public int describeContents() { + return 0; + } + + public AccountInfo(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.validuntil = in.readLong(); + this.login = in.readString(); + this.options = new HashMap<String, List<String>>(); + in.readMap(this.options, AccountInfo.class.getClassLoader()); + this.valid = (in.readInt() == 1); + this.trafficleft = in.readLong(); + this.maxtraffic = in.readLong(); + this.premium = (in.readInt() == 1); + this.type = in.readString(); + } + + public static final android.os.Parcelable.Creator<AccountInfo> CREATOR = new android.os.Parcelable.Creator<AccountInfo>() { + @Override + public AccountInfo[] newArray(int size) { + return new AccountInfo[size]; + } + + @Override + public AccountInfo createFromParcel(android.os.Parcel in) { + return new AccountInfo(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + VALIDUNTIL((short) 1, "validuntil"), + LOGIN((short) 2, "login"), + OPTIONS((short) 3, "options"), + VALID((short) 4, "valid"), + TRAFFICLEFT((short) 5, "trafficleft"), + MAXTRAFFIC((short) 6, "maxtraffic"), + PREMIUM((short) 7, "premium"), + TYPE((short) 8, "type"); + + 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: // VALIDUNTIL + return VALIDUNTIL; + case 2: // LOGIN + return LOGIN; + case 3: // OPTIONS + return OPTIONS; + case 4: // VALID + return VALID; + case 5: // TRAFFICLEFT + return TRAFFICLEFT; + case 6: // MAXTRAFFIC + return MAXTRAFFIC; + case 7: // PREMIUM + return PREMIUM; + case 8: // 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __VALIDUNTIL_ISSET_ID = 0; + private static final int __VALID_ISSET_ID = 1; + private static final int __TRAFFICLEFT_ISSET_ID = 2; + private static final int __MAXTRAFFIC_ISSET_ID = 3; + private static final int __PREMIUM_ISSET_ID = 4; + private byte __isset_bitfield = 0; + 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.VALIDUNTIL, new org.apache.thrift.meta_data.FieldMetaData("validuntil", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.LOGIN, new org.apache.thrift.meta_data.FieldMetaData("login", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OPTIONS, new org.apache.thrift.meta_data.FieldMetaData("options", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))))); + tmpMap.put(_Fields.VALID, new org.apache.thrift.meta_data.FieldMetaData("valid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.TRAFFICLEFT, new org.apache.thrift.meta_data.FieldMetaData("trafficleft", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.MAXTRAFFIC, new org.apache.thrift.meta_data.FieldMetaData("maxtraffic", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.PREMIUM, new org.apache.thrift.meta_data.FieldMetaData("premium", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AccountInfo.class, metaDataMap); + } + + public AccountInfo() { + } + + public AccountInfo( + long validuntil, + String login, + Map<String, List<String>> options, + boolean valid, + long trafficleft, + long maxtraffic, + boolean premium, + String type) { + this(); + this.validuntil = validuntil; + setValiduntilIsSet(true); + this.login = login; + this.options = options; + this.valid = valid; + setValidIsSet(true); + this.trafficleft = trafficleft; + setTrafficleftIsSet(true); + this.maxtraffic = maxtraffic; + setMaxtrafficIsSet(true); + this.premium = premium; + setPremiumIsSet(true); + this.type = type; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __VALIDUNTIL_ISSET_ID = 0; - private static final int __VALID_ISSET_ID = 1; - private static final int __TRAFFICLEFT_ISSET_ID = 2; - private static final int __MAXTRAFFIC_ISSET_ID = 3; - private static final int __PREMIUM_ISSET_ID = 4; - private BitSet __isset_bit_vector = new BitSet(5); - 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.VALIDUNTIL, new org.apache.thrift.meta_data.FieldMetaData("validuntil", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.LOGIN, new org.apache.thrift.meta_data.FieldMetaData("login", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.OPTIONS, new org.apache.thrift.meta_data.FieldMetaData("options", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))))); - tmpMap.put(_Fields.VALID, new org.apache.thrift.meta_data.FieldMetaData("valid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.TRAFFICLEFT, new org.apache.thrift.meta_data.FieldMetaData("trafficleft", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.MAXTRAFFIC, new org.apache.thrift.meta_data.FieldMetaData("maxtraffic", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.PREMIUM, new org.apache.thrift.meta_data.FieldMetaData("premium", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(AccountInfo.class, metaDataMap); - } - - public AccountInfo() { - } - - public AccountInfo( - long validuntil, - String login, - Map<String,List<String>> options, - boolean valid, - long trafficleft, - long maxtraffic, - boolean premium, - String type) - { - this(); - this.validuntil = validuntil; - setValiduntilIsSet(true); - this.login = login; - this.options = options; - this.valid = valid; - setValidIsSet(true); - this.trafficleft = trafficleft; - setTrafficleftIsSet(true); - this.maxtraffic = maxtraffic; - setMaxtrafficIsSet(true); - this.premium = premium; - setPremiumIsSet(true); - this.type = type; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public AccountInfo(AccountInfo other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.validuntil = other.validuntil; - if (other.isSetLogin()) { - this.login = other.login; - } - if (other.isSetOptions()) { - Map<String,List<String>> __this__options = new HashMap<String,List<String>>(); - for (Map.Entry<String, List<String>> other_element : other.options.entrySet()) { - - String other_element_key = other_element.getKey(); - List<String> other_element_value = other_element.getValue(); - - String __this__options_copy_key = other_element_key; - - List<String> __this__options_copy_value = new ArrayList<String>(); - for (String other_element_value_element : other_element_value) { - __this__options_copy_value.add(other_element_value_element); + public AccountInfo(AccountInfo other) { + __isset_bitfield = other.__isset_bitfield; + this.validuntil = other.validuntil; + if (other.isSetLogin()) { + this.login = other.login; } + if (other.isSetOptions()) { + Map<String, List<String>> __this__options = new HashMap<String, List<String>>(other.options.size()); + for (Map.Entry<String, List<String>> other_element : other.options.entrySet()) { - __this__options.put(__this__options_copy_key, __this__options_copy_value); - } - this.options = __this__options; - } - this.valid = other.valid; - this.trafficleft = other.trafficleft; - this.maxtraffic = other.maxtraffic; - this.premium = other.premium; - if (other.isSetType()) { - this.type = other.type; - } - } - - public AccountInfo deepCopy() { - return new AccountInfo(this); - } - - @Override - public void clear() { - setValiduntilIsSet(false); - this.validuntil = 0; - this.login = null; - this.options = null; - setValidIsSet(false); - this.valid = false; - setTrafficleftIsSet(false); - this.trafficleft = 0; - setMaxtrafficIsSet(false); - this.maxtraffic = 0; - setPremiumIsSet(false); - this.premium = false; - this.type = null; - } - - public long getValiduntil() { - return this.validuntil; - } - - public AccountInfo setValiduntil(long validuntil) { - this.validuntil = validuntil; - setValiduntilIsSet(true); - return this; - } - - public void unsetValiduntil() { - __isset_bit_vector.clear(__VALIDUNTIL_ISSET_ID); - } - - /** Returns true if field validuntil is set (has been assigned a value) and false otherwise */ - public boolean isSetValiduntil() { - return __isset_bit_vector.get(__VALIDUNTIL_ISSET_ID); - } - - public void setValiduntilIsSet(boolean value) { - __isset_bit_vector.set(__VALIDUNTIL_ISSET_ID, value); - } - - public String getLogin() { - return this.login; - } - - public AccountInfo setLogin(String login) { - this.login = login; - return this; - } - - public void unsetLogin() { - this.login = null; - } - - /** Returns true if field login is set (has been assigned a value) and false otherwise */ - public boolean isSetLogin() { - return this.login != null; - } - - public void setLoginIsSet(boolean value) { - if (!value) { - this.login = null; - } - } - - public int getOptionsSize() { - return (this.options == null) ? 0 : this.options.size(); - } - - public void putToOptions(String key, List<String> val) { - if (this.options == null) { - this.options = new HashMap<String,List<String>>(); - } - this.options.put(key, val); - } - - public Map<String,List<String>> getOptions() { - return this.options; - } - - public AccountInfo setOptions(Map<String,List<String>> options) { - this.options = options; - return this; - } - - public void unsetOptions() { - this.options = null; - } - - /** Returns true if field options is set (has been assigned a value) and false otherwise */ - public boolean isSetOptions() { - return this.options != null; - } - - public void setOptionsIsSet(boolean value) { - if (!value) { - this.options = null; - } - } - - public boolean isValid() { - return this.valid; - } - - public AccountInfo setValid(boolean valid) { - this.valid = valid; - setValidIsSet(true); - return this; - } - - public void unsetValid() { - __isset_bit_vector.clear(__VALID_ISSET_ID); - } - - /** Returns true if field valid is set (has been assigned a value) and false otherwise */ - public boolean isSetValid() { - return __isset_bit_vector.get(__VALID_ISSET_ID); - } - - public void setValidIsSet(boolean value) { - __isset_bit_vector.set(__VALID_ISSET_ID, value); - } - - public long getTrafficleft() { - return this.trafficleft; - } - - public AccountInfo setTrafficleft(long trafficleft) { - this.trafficleft = trafficleft; - setTrafficleftIsSet(true); - return this; - } - - public void unsetTrafficleft() { - __isset_bit_vector.clear(__TRAFFICLEFT_ISSET_ID); - } - - /** Returns true if field trafficleft is set (has been assigned a value) and false otherwise */ - public boolean isSetTrafficleft() { - return __isset_bit_vector.get(__TRAFFICLEFT_ISSET_ID); - } - - public void setTrafficleftIsSet(boolean value) { - __isset_bit_vector.set(__TRAFFICLEFT_ISSET_ID, value); - } - - public long getMaxtraffic() { - return this.maxtraffic; - } - - public AccountInfo setMaxtraffic(long maxtraffic) { - this.maxtraffic = maxtraffic; - setMaxtrafficIsSet(true); - return this; - } - - public void unsetMaxtraffic() { - __isset_bit_vector.clear(__MAXTRAFFIC_ISSET_ID); - } - - /** Returns true if field maxtraffic is set (has been assigned a value) and false otherwise */ - public boolean isSetMaxtraffic() { - return __isset_bit_vector.get(__MAXTRAFFIC_ISSET_ID); - } - - public void setMaxtrafficIsSet(boolean value) { - __isset_bit_vector.set(__MAXTRAFFIC_ISSET_ID, value); - } - - public boolean isPremium() { - return this.premium; - } - - public AccountInfo setPremium(boolean premium) { - this.premium = premium; - setPremiumIsSet(true); - return this; - } - - public void unsetPremium() { - __isset_bit_vector.clear(__PREMIUM_ISSET_ID); - } - - /** Returns true if field premium is set (has been assigned a value) and false otherwise */ - public boolean isSetPremium() { - return __isset_bit_vector.get(__PREMIUM_ISSET_ID); - } - - public void setPremiumIsSet(boolean value) { - __isset_bit_vector.set(__PREMIUM_ISSET_ID, value); - } - - public String getType() { - return this.type; - } - - public AccountInfo setType(String type) { - this.type = type; - return this; - } - - public void unsetType() { - this.type = null; - } - - /** Returns true if field type is set (has been assigned a value) and false otherwise */ - public boolean isSetType() { - return this.type != null; - } - - public void setTypeIsSet(boolean value) { - if (!value) { - this.type = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case VALIDUNTIL: - if (value == null) { - unsetValiduntil(); - } else { - setValiduntil((Long)value); - } - break; - - case LOGIN: - if (value == null) { - unsetLogin(); - } else { - setLogin((String)value); - } - break; - - case OPTIONS: - if (value == null) { - unsetOptions(); - } else { - setOptions((Map<String,List<String>>)value); - } - break; - - case VALID: - if (value == null) { - unsetValid(); - } else { - setValid((Boolean)value); - } - break; - - case TRAFFICLEFT: - if (value == null) { - unsetTrafficleft(); - } else { - setTrafficleft((Long)value); - } - break; - - case MAXTRAFFIC: - if (value == null) { - unsetMaxtraffic(); - } else { - setMaxtraffic((Long)value); - } - break; - - case PREMIUM: - if (value == null) { - unsetPremium(); - } else { - setPremium((Boolean)value); - } - break; - - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case VALIDUNTIL: - return Long.valueOf(getValiduntil()); - - case LOGIN: - return getLogin(); - - case OPTIONS: - return getOptions(); - - case VALID: - return Boolean.valueOf(isValid()); - - case TRAFFICLEFT: - return Long.valueOf(getTrafficleft()); - - case MAXTRAFFIC: - return Long.valueOf(getMaxtraffic()); - - case PREMIUM: - return Boolean.valueOf(isPremium()); - - case TYPE: - return getType(); - - } - 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 VALIDUNTIL: - return isSetValiduntil(); - case LOGIN: - return isSetLogin(); - case OPTIONS: - return isSetOptions(); - case VALID: - return isSetValid(); - case TRAFFICLEFT: - return isSetTrafficleft(); - case MAXTRAFFIC: - return isSetMaxtraffic(); - case PREMIUM: - return isSetPremium(); - case TYPE: - return isSetType(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof AccountInfo) - return this.equals((AccountInfo)that); - return false; - } - - public boolean equals(AccountInfo that) { - if (that == null) - return false; - - boolean this_present_validuntil = true; - boolean that_present_validuntil = true; - if (this_present_validuntil || that_present_validuntil) { - if (!(this_present_validuntil && that_present_validuntil)) - return false; - if (this.validuntil != that.validuntil) - return false; + String other_element_key = other_element.getKey(); + List<String> other_element_value = other_element.getValue(); + + String __this__options_copy_key = other_element_key; + + List<String> __this__options_copy_value = new ArrayList<String>(other_element_value); + + __this__options.put(__this__options_copy_key, __this__options_copy_value); + } + this.options = __this__options; + } + this.valid = other.valid; + this.trafficleft = other.trafficleft; + this.maxtraffic = other.maxtraffic; + this.premium = other.premium; + if (other.isSetType()) { + this.type = other.type; + } } - boolean this_present_login = true && this.isSetLogin(); - boolean that_present_login = true && that.isSetLogin(); - if (this_present_login || that_present_login) { - if (!(this_present_login && that_present_login)) - return false; - if (!this.login.equals(that.login)) - return false; + public AccountInfo deepCopy() { + return new AccountInfo(this); } - boolean this_present_options = true && this.isSetOptions(); - boolean that_present_options = true && that.isSetOptions(); - if (this_present_options || that_present_options) { - if (!(this_present_options && that_present_options)) - return false; - if (!this.options.equals(that.options)) - return false; + @Override + public void clear() { + setValiduntilIsSet(false); + this.validuntil = 0; + this.login = null; + this.options = null; + setValidIsSet(false); + this.valid = false; + setTrafficleftIsSet(false); + this.trafficleft = 0; + setMaxtrafficIsSet(false); + this.maxtraffic = 0; + setPremiumIsSet(false); + this.premium = false; + this.type = null; } - boolean this_present_valid = true; - boolean that_present_valid = true; - if (this_present_valid || that_present_valid) { - if (!(this_present_valid && that_present_valid)) - return false; - if (this.valid != that.valid) - return false; + public long getValiduntil() { + return this.validuntil; } - boolean this_present_trafficleft = true; - boolean that_present_trafficleft = true; - if (this_present_trafficleft || that_present_trafficleft) { - if (!(this_present_trafficleft && that_present_trafficleft)) - return false; - if (this.trafficleft != that.trafficleft) - return false; + public AccountInfo setValiduntil(long validuntil) { + this.validuntil = validuntil; + setValiduntilIsSet(true); + return this; } - boolean this_present_maxtraffic = true; - boolean that_present_maxtraffic = true; - if (this_present_maxtraffic || that_present_maxtraffic) { - if (!(this_present_maxtraffic && that_present_maxtraffic)) - return false; - if (this.maxtraffic != that.maxtraffic) - return false; + public void unsetValiduntil() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __VALIDUNTIL_ISSET_ID); } - boolean this_present_premium = true; - boolean that_present_premium = true; - if (this_present_premium || that_present_premium) { - if (!(this_present_premium && that_present_premium)) - return false; - if (this.premium != that.premium) - return false; + /** Returns true if field validuntil is set (has been assigned a value) and false otherwise */ + public boolean isSetValiduntil() { + return EncodingUtils.testBit(__isset_bitfield, __VALIDUNTIL_ISSET_ID); } - 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.equals(that.type)) + public void setValiduntilIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __VALIDUNTIL_ISSET_ID, value); + } + + public String getLogin() { + return this.login; + } + + public AccountInfo setLogin(String login) { + this.login = login; + return this; + } + + public void unsetLogin() { + this.login = null; + } + + /** Returns true if field login is set (has been assigned a value) and false otherwise */ + public boolean isSetLogin() { + return this.login != null; + } + + public void setLoginIsSet(boolean value) { + if (!value) { + this.login = null; + } + } + + public int getOptionsSize() { + return (this.options == null) ? 0 : this.options.size(); + } + + public void putToOptions(String key, List<String> val) { + if (this.options == null) { + this.options = new HashMap<String, List<String>>(); + } + this.options.put(key, val); + } + + public Map<String, List<String>> getOptions() { + return this.options; + } + + public AccountInfo setOptions(Map<String, List<String>> options) { + this.options = options; + return this; + } + + public void unsetOptions() { + this.options = null; + } + + /** Returns true if field options is set (has been assigned a value) and false otherwise */ + public boolean isSetOptions() { + return this.options != null; + } + + public void setOptionsIsSet(boolean value) { + if (!value) { + this.options = null; + } + } + + public boolean isValid() { + return this.valid; + } + + public AccountInfo setValid(boolean valid) { + this.valid = valid; + setValidIsSet(true); + return this; + } + + public void unsetValid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __VALID_ISSET_ID); + } + + /** Returns true if field valid is set (has been assigned a value) and false otherwise */ + public boolean isSetValid() { + return EncodingUtils.testBit(__isset_bitfield, __VALID_ISSET_ID); + } + + public void setValidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __VALID_ISSET_ID, value); + } + + public long getTrafficleft() { + return this.trafficleft; + } + + public AccountInfo setTrafficleft(long trafficleft) { + this.trafficleft = trafficleft; + setTrafficleftIsSet(true); + return this; + } + + public void unsetTrafficleft() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TRAFFICLEFT_ISSET_ID); + } + + /** Returns true if field trafficleft is set (has been assigned a value) and false otherwise */ + public boolean isSetTrafficleft() { + return EncodingUtils.testBit(__isset_bitfield, __TRAFFICLEFT_ISSET_ID); + } + + public void setTrafficleftIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TRAFFICLEFT_ISSET_ID, value); + } + + public long getMaxtraffic() { + return this.maxtraffic; + } + + public AccountInfo setMaxtraffic(long maxtraffic) { + this.maxtraffic = maxtraffic; + setMaxtrafficIsSet(true); + return this; + } + + public void unsetMaxtraffic() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __MAXTRAFFIC_ISSET_ID); + } + + /** Returns true if field maxtraffic is set (has been assigned a value) and false otherwise */ + public boolean isSetMaxtraffic() { + return EncodingUtils.testBit(__isset_bitfield, __MAXTRAFFIC_ISSET_ID); + } + + public void setMaxtrafficIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __MAXTRAFFIC_ISSET_ID, value); + } + + public boolean isPremium() { + return this.premium; + } + + public AccountInfo setPremium(boolean premium) { + this.premium = premium; + setPremiumIsSet(true); + return this; + } + + public void unsetPremium() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PREMIUM_ISSET_ID); + } + + /** Returns true if field premium is set (has been assigned a value) and false otherwise */ + public boolean isSetPremium() { + return EncodingUtils.testBit(__isset_bitfield, __PREMIUM_ISSET_ID); + } + + public void setPremiumIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PREMIUM_ISSET_ID, value); + } + + public String getType() { + return this.type; + } + + public AccountInfo setType(String type) { + this.type = type; + return this; + } + + public void unsetType() { + this.type = null; + } + + /** Returns true if field type is set (has been assigned a value) and false otherwise */ + public boolean isSetType() { + return this.type != null; + } + + public void setTypeIsSet(boolean value) { + if (!value) { + this.type = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case VALIDUNTIL: + if (value == null) { + unsetValiduntil(); + } else { + setValiduntil((Long) value); + } + break; + + case LOGIN: + if (value == null) { + unsetLogin(); + } else { + setLogin((String) value); + } + break; + + case OPTIONS: + if (value == null) { + unsetOptions(); + } else { + setOptions((Map<String, List<String>>) value); + } + break; + + case VALID: + if (value == null) { + unsetValid(); + } else { + setValid((Boolean) value); + } + break; + + case TRAFFICLEFT: + if (value == null) { + unsetTrafficleft(); + } else { + setTrafficleft((Long) value); + } + break; + + case MAXTRAFFIC: + if (value == null) { + unsetMaxtraffic(); + } else { + setMaxtraffic((Long) value); + } + break; + + case PREMIUM: + if (value == null) { + unsetPremium(); + } else { + setPremium((Boolean) value); + } + break; + + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case VALIDUNTIL: + return getValiduntil(); + + case LOGIN: + return getLogin(); + + case OPTIONS: + return getOptions(); + + case VALID: + return isValid(); + + case TRAFFICLEFT: + return getTrafficleft(); + + case MAXTRAFFIC: + return getMaxtraffic(); + + case PREMIUM: + return isPremium(); + + case TYPE: + return getType(); + + } + 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 VALIDUNTIL: + return isSetValiduntil(); + case LOGIN: + return isSetLogin(); + case OPTIONS: + return isSetOptions(); + case VALID: + return isSetValid(); + case TRAFFICLEFT: + return isSetTrafficleft(); + case MAXTRAFFIC: + return isSetMaxtraffic(); + case PREMIUM: + return isSetPremium(); + case TYPE: + return isSetType(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof AccountInfo) + return this.equals((AccountInfo) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(AccountInfo other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - AccountInfo typedOther = (AccountInfo)other; - - lastComparison = Boolean.valueOf(isSetValiduntil()).compareTo(typedOther.isSetValiduntil()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetValiduntil()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.validuntil, typedOther.validuntil); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLogin()).compareTo(typedOther.isSetLogin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLogin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.login, typedOther.login); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOptions()).compareTo(typedOther.isSetOptions()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOptions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.options, typedOther.options); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetValid()).compareTo(typedOther.isSetValid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetValid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.valid, typedOther.valid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetTrafficleft()).compareTo(typedOther.isSetTrafficleft()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTrafficleft()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.trafficleft, typedOther.trafficleft); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetMaxtraffic()).compareTo(typedOther.isSetMaxtraffic()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetMaxtraffic()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxtraffic, typedOther.maxtraffic); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPremium()).compareTo(typedOther.isSetPremium()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPremium()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.premium, typedOther.premium); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); - 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("AccountInfo("); - boolean first = true; - - sb.append("validuntil:"); - sb.append(this.validuntil); - first = false; - if (!first) sb.append(", "); - sb.append("login:"); - if (this.login == null) { - sb.append("null"); - } else { - sb.append(this.login); - } - first = false; - if (!first) sb.append(", "); - sb.append("options:"); - if (this.options == null) { - sb.append("null"); - } else { - sb.append(this.options); - } - first = false; - if (!first) sb.append(", "); - sb.append("valid:"); - sb.append(this.valid); - first = false; - if (!first) sb.append(", "); - sb.append("trafficleft:"); - sb.append(this.trafficleft); - first = false; - if (!first) sb.append(", "); - sb.append("maxtraffic:"); - sb.append(this.maxtraffic); - first = false; - if (!first) sb.append(", "); - sb.append("premium:"); - sb.append(this.premium); - first = false; - if (!first) sb.append(", "); - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class AccountInfoStandardSchemeFactory implements SchemeFactory { - public AccountInfoStandardScheme getScheme() { - return new AccountInfoStandardScheme(); - } - } - - private static class AccountInfoStandardScheme extends StandardScheme<AccountInfo> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, AccountInfo 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; + public boolean equals(AccountInfo that) { + if (that == null) + return false; + + boolean this_present_validuntil = true; + boolean that_present_validuntil = true; + if (this_present_validuntil || that_present_validuntil) { + if (!(this_present_validuntil && that_present_validuntil)) + return false; + if (this.validuntil != that.validuntil) + return false; } - switch (schemeField.id) { - case 1: // VALIDUNTIL - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.validuntil = iprot.readI64(); - struct.setValiduntilIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // LOGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.login = iprot.readString(); - struct.setLoginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + + boolean this_present_login = true && this.isSetLogin(); + boolean that_present_login = true && that.isSetLogin(); + if (this_present_login || that_present_login) { + if (!(this_present_login && that_present_login)) + return false; + if (!this.login.equals(that.login)) + return false; + } + + boolean this_present_options = true && this.isSetOptions(); + boolean that_present_options = true && that.isSetOptions(); + if (this_present_options || that_present_options) { + if (!(this_present_options && that_present_options)) + return false; + if (!this.options.equals(that.options)) + return false; + } + + boolean this_present_valid = true; + boolean that_present_valid = true; + if (this_present_valid || that_present_valid) { + if (!(this_present_valid && that_present_valid)) + return false; + if (this.valid != that.valid) + return false; + } + + boolean this_present_trafficleft = true; + boolean that_present_trafficleft = true; + if (this_present_trafficleft || that_present_trafficleft) { + if (!(this_present_trafficleft && that_present_trafficleft)) + return false; + if (this.trafficleft != that.trafficleft) + return false; + } + + boolean this_present_maxtraffic = true; + boolean that_present_maxtraffic = true; + if (this_present_maxtraffic || that_present_maxtraffic) { + if (!(this_present_maxtraffic && that_present_maxtraffic)) + return false; + if (this.maxtraffic != that.maxtraffic) + return false; + } + + boolean this_present_premium = true; + boolean that_present_premium = true; + if (this_present_premium || that_present_premium) { + if (!(this_present_premium && that_present_premium)) + return false; + if (this.premium != that.premium) + 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.equals(that.type)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_validuntil = true; + list.add(present_validuntil); + if (present_validuntil) + list.add(validuntil); + + boolean present_login = true && (isSetLogin()); + list.add(present_login); + if (present_login) + list.add(login); + + boolean present_options = true && (isSetOptions()); + list.add(present_options); + if (present_options) + list.add(options); + + boolean present_valid = true; + list.add(present_valid); + if (present_valid) + list.add(valid); + + boolean present_trafficleft = true; + list.add(present_trafficleft); + if (present_trafficleft) + list.add(trafficleft); + + boolean present_maxtraffic = true; + list.add(present_maxtraffic); + if (present_maxtraffic) + list.add(maxtraffic); + + boolean present_premium = true; + list.add(present_premium); + if (present_premium) + list.add(premium); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type); + + return list.hashCode(); + } + + @Override + public int compareTo(AccountInfo other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetValiduntil()).compareTo(other.isSetValiduntil()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValiduntil()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.validuntil, other.validuntil); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // OPTIONS - if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { - { - org.apache.thrift.protocol.TMap _map24 = iprot.readMapBegin(); - struct.options = new HashMap<String,List<String>>(2*_map24.size); - for (int _i25 = 0; _i25 < _map24.size; ++_i25) - { - String _key26; // required - List<String> _val27; // required - _key26 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list28 = iprot.readListBegin(); - _val27 = new ArrayList<String>(_list28.size); - for (int _i29 = 0; _i29 < _list28.size; ++_i29) - { - String _elem30; // required - _elem30 = iprot.readString(); - _val27.add(_elem30); - } - iprot.readListEnd(); - } - struct.options.put(_key26, _val27); - } - iprot.readMapEnd(); - } - struct.setOptionsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetLogin()).compareTo(other.isSetLogin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLogin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.login, other.login); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // VALID - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.valid = iprot.readBool(); - struct.setValidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetOptions()).compareTo(other.isSetOptions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOptions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.options, other.options); + if (lastComparison != 0) { + return lastComparison; } - break; - case 5: // TRAFFICLEFT - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.trafficleft = iprot.readI64(); - struct.setTrafficleftIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetValid()).compareTo(other.isSetValid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.valid, other.valid); + if (lastComparison != 0) { + return lastComparison; } - break; - case 6: // MAXTRAFFIC - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.maxtraffic = iprot.readI64(); - struct.setMaxtrafficIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetTrafficleft()).compareTo(other.isSetTrafficleft()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTrafficleft()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.trafficleft, other.trafficleft); + if (lastComparison != 0) { + return lastComparison; } - break; - case 7: // PREMIUM - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.premium = iprot.readBool(); - struct.setPremiumIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetMaxtraffic()).compareTo(other.isSetMaxtraffic()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetMaxtraffic()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.maxtraffic, other.maxtraffic); + if (lastComparison != 0) { + return lastComparison; } - break; - case 8: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPremium()).compareTo(other.isSetPremium()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPremium()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.premium, other.premium); + if (lastComparison != 0) { + return lastComparison; } - 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, AccountInfo struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(VALIDUNTIL_FIELD_DESC); - oprot.writeI64(struct.validuntil); - oprot.writeFieldEnd(); - if (struct.login != null) { - oprot.writeFieldBegin(LOGIN_FIELD_DESC); - oprot.writeString(struct.login); - oprot.writeFieldEnd(); - } - if (struct.options != null) { - oprot.writeFieldBegin(OPTIONS_FIELD_DESC); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, struct.options.size())); - for (Map.Entry<String, List<String>> _iter31 : struct.options.entrySet()) - { - oprot.writeString(_iter31.getKey()); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter31.getValue().size())); - for (String _iter32 : _iter31.getValue()) - { - oprot.writeString(_iter32); - } - oprot.writeListEnd(); + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; } - } - oprot.writeMapEnd(); } - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(VALID_FIELD_DESC); - oprot.writeBool(struct.valid); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(TRAFFICLEFT_FIELD_DESC); - oprot.writeI64(struct.trafficleft); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(MAXTRAFFIC_FIELD_DESC); - oprot.writeI64(struct.maxtraffic); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(PREMIUM_FIELD_DESC); - oprot.writeBool(struct.premium); - oprot.writeFieldEnd(); - if (struct.type != null) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeString(struct.type); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class AccountInfoTupleSchemeFactory implements SchemeFactory { - public AccountInfoTupleScheme getScheme() { - return new AccountInfoTupleScheme(); - } - } - - private static class AccountInfoTupleScheme extends TupleScheme<AccountInfo> { + 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 void write(org.apache.thrift.protocol.TProtocol prot, AccountInfo struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetValiduntil()) { - optionals.set(0); - } - if (struct.isSetLogin()) { - optionals.set(1); - } - if (struct.isSetOptions()) { - optionals.set(2); - } - if (struct.isSetValid()) { - optionals.set(3); - } - if (struct.isSetTrafficleft()) { - optionals.set(4); - } - if (struct.isSetMaxtraffic()) { - optionals.set(5); - } - if (struct.isSetPremium()) { - optionals.set(6); - } - if (struct.isSetType()) { - optionals.set(7); - } - oprot.writeBitSet(optionals, 8); - if (struct.isSetValiduntil()) { - oprot.writeI64(struct.validuntil); - } - if (struct.isSetLogin()) { - oprot.writeString(struct.login); - } - if (struct.isSetOptions()) { - { - oprot.writeI32(struct.options.size()); - for (Map.Entry<String, List<String>> _iter33 : struct.options.entrySet()) - { - oprot.writeString(_iter33.getKey()); - { - oprot.writeI32(_iter33.getValue().size()); - for (String _iter34 : _iter33.getValue()) - { - oprot.writeString(_iter34); - } + public String toString() { + StringBuilder sb = new StringBuilder("AccountInfo("); + boolean first = true; + + sb.append("validuntil:"); + sb.append(this.validuntil); + first = false; + if (!first) sb.append(", "); + sb.append("login:"); + if (this.login == null) { + sb.append("null"); + } else { + sb.append(this.login); + } + first = false; + if (!first) sb.append(", "); + sb.append("options:"); + if (this.options == null) { + sb.append("null"); + } else { + sb.append(this.options); + } + first = false; + if (!first) sb.append(", "); + sb.append("valid:"); + sb.append(this.valid); + first = false; + if (!first) sb.append(", "); + sb.append("trafficleft:"); + sb.append(this.trafficleft); + first = false; + if (!first) sb.append(", "); + sb.append("maxtraffic:"); + sb.append(this.maxtraffic); + first = false; + if (!first) sb.append(", "); + sb.append("premium:"); + sb.append(this.premium); + first = false; + if (!first) sb.append(", "); + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 AccountInfoStandardSchemeFactory implements SchemeFactory { + public AccountInfoStandardScheme getScheme() { + return new AccountInfoStandardScheme(); + } + } + + private static class AccountInfoStandardScheme extends StandardScheme<AccountInfo> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, AccountInfo 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: // VALIDUNTIL + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.validuntil = iprot.readI64(); + struct.setValiduntilIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // LOGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.login = iprot.readString(); + struct.setLoginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // OPTIONS + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map48 = iprot.readMapBegin(); + struct.options = new HashMap<String, List<String>>(2 * _map48.size); + String _key49; + List<String> _val50; + for (int _i51 = 0; _i51 < _map48.size; ++_i51) { + _key49 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list52 = iprot.readListBegin(); + _val50 = new ArrayList<String>(_list52.size); + String _elem53; + for (int _i54 = 0; _i54 < _list52.size; ++_i54) { + _elem53 = iprot.readString(); + _val50.add(_elem53); + } + iprot.readListEnd(); + } + struct.options.put(_key49, _val50); + } + iprot.readMapEnd(); + } + struct.setOptionsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // VALID + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.valid = iprot.readBool(); + struct.setValidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // TRAFFICLEFT + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.trafficleft = iprot.readI64(); + struct.setTrafficleftIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // MAXTRAFFIC + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.maxtraffic = iprot.readI64(); + struct.setMaxtrafficIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // PREMIUM + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.premium = iprot.readBool(); + struct.setPremiumIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.type = iprot.readString(); + 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, AccountInfo struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(VALIDUNTIL_FIELD_DESC); + oprot.writeI64(struct.validuntil); + oprot.writeFieldEnd(); + if (struct.login != null) { + oprot.writeFieldBegin(LOGIN_FIELD_DESC); + oprot.writeString(struct.login); + oprot.writeFieldEnd(); + } + if (struct.options != null) { + oprot.writeFieldBegin(OPTIONS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, struct.options.size())); + for (Map.Entry<String, List<String>> _iter55 : struct.options.entrySet()) { + oprot.writeString(_iter55.getKey()); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter55.getValue().size())); + for (String _iter56 : _iter55.getValue()) { + oprot.writeString(_iter56); + } + oprot.writeListEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(VALID_FIELD_DESC); + oprot.writeBool(struct.valid); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(TRAFFICLEFT_FIELD_DESC); + oprot.writeI64(struct.trafficleft); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(MAXTRAFFIC_FIELD_DESC); + oprot.writeI64(struct.maxtraffic); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(PREMIUM_FIELD_DESC); + oprot.writeBool(struct.premium); + oprot.writeFieldEnd(); + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeString(struct.type); + oprot.writeFieldEnd(); } - } + oprot.writeFieldStop(); + oprot.writeStructEnd(); } - } - if (struct.isSetValid()) { - oprot.writeBool(struct.valid); - } - if (struct.isSetTrafficleft()) { - oprot.writeI64(struct.trafficleft); - } - if (struct.isSetMaxtraffic()) { - oprot.writeI64(struct.maxtraffic); - } - if (struct.isSetPremium()) { - oprot.writeBool(struct.premium); - } - if (struct.isSetType()) { - oprot.writeString(struct.type); - } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, AccountInfo struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(8); - if (incoming.get(0)) { - struct.validuntil = iprot.readI64(); - struct.setValiduntilIsSet(true); - } - if (incoming.get(1)) { - struct.login = iprot.readString(); - struct.setLoginIsSet(true); - } - if (incoming.get(2)) { - { - org.apache.thrift.protocol.TMap _map35 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); - struct.options = new HashMap<String,List<String>>(2*_map35.size); - for (int _i36 = 0; _i36 < _map35.size; ++_i36) - { - String _key37; // required - List<String> _val38; // required - _key37 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list39 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val38 = new ArrayList<String>(_list39.size); - for (int _i40 = 0; _i40 < _list39.size; ++_i40) - { - String _elem41; // required - _elem41 = iprot.readString(); - _val38.add(_elem41); - } + private static class AccountInfoTupleSchemeFactory implements SchemeFactory { + public AccountInfoTupleScheme getScheme() { + return new AccountInfoTupleScheme(); + } + } + + private static class AccountInfoTupleScheme extends TupleScheme<AccountInfo> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, AccountInfo struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetValiduntil()) { + optionals.set(0); + } + if (struct.isSetLogin()) { + optionals.set(1); + } + if (struct.isSetOptions()) { + optionals.set(2); + } + if (struct.isSetValid()) { + optionals.set(3); + } + if (struct.isSetTrafficleft()) { + optionals.set(4); + } + if (struct.isSetMaxtraffic()) { + optionals.set(5); + } + if (struct.isSetPremium()) { + optionals.set(6); + } + if (struct.isSetType()) { + optionals.set(7); + } + oprot.writeBitSet(optionals, 8); + if (struct.isSetValiduntil()) { + oprot.writeI64(struct.validuntil); + } + if (struct.isSetLogin()) { + oprot.writeString(struct.login); + } + if (struct.isSetOptions()) { + { + oprot.writeI32(struct.options.size()); + for (Map.Entry<String, List<String>> _iter57 : struct.options.entrySet()) { + oprot.writeString(_iter57.getKey()); + { + oprot.writeI32(_iter57.getValue().size()); + for (String _iter58 : _iter57.getValue()) { + oprot.writeString(_iter58); + } + } + } + } + } + if (struct.isSetValid()) { + oprot.writeBool(struct.valid); + } + if (struct.isSetTrafficleft()) { + oprot.writeI64(struct.trafficleft); + } + if (struct.isSetMaxtraffic()) { + oprot.writeI64(struct.maxtraffic); + } + if (struct.isSetPremium()) { + oprot.writeBool(struct.premium); + } + if (struct.isSetType()) { + oprot.writeString(struct.type); } - struct.options.put(_key37, _val38); - } } - struct.setOptionsIsSet(true); - } - if (incoming.get(3)) { - struct.valid = iprot.readBool(); - struct.setValidIsSet(true); - } - if (incoming.get(4)) { - struct.trafficleft = iprot.readI64(); - struct.setTrafficleftIsSet(true); - } - if (incoming.get(5)) { - struct.maxtraffic = iprot.readI64(); - struct.setMaxtrafficIsSet(true); - } - if (incoming.get(6)) { - struct.premium = iprot.readBool(); - struct.setPremiumIsSet(true); - } - if (incoming.get(7)) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } - } - } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, AccountInfo struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(8); + if (incoming.get(0)) { + struct.validuntil = iprot.readI64(); + struct.setValiduntilIsSet(true); + } + if (incoming.get(1)) { + struct.login = iprot.readString(); + struct.setLoginIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TMap _map59 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.options = new HashMap<String, List<String>>(2 * _map59.size); + String _key60; + List<String> _val61; + for (int _i62 = 0; _i62 < _map59.size; ++_i62) { + _key60 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list63 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val61 = new ArrayList<String>(_list63.size); + String _elem64; + for (int _i65 = 0; _i65 < _list63.size; ++_i65) { + _elem64 = iprot.readString(); + _val61.add(_elem64); + } + } + struct.options.put(_key60, _val61); + } + } + struct.setOptionsIsSet(true); + } + if (incoming.get(3)) { + struct.valid = iprot.readBool(); + struct.setValidIsSet(true); + } + if (incoming.get(4)) { + struct.trafficleft = iprot.readI64(); + struct.setTrafficleftIsSet(true); + } + if (incoming.get(5)) { + struct.maxtraffic = iprot.readI64(); + struct.setMaxtrafficIsSet(true); + } + if (incoming.get(6)) { + struct.premium = iprot.readBool(); + struct.setPremiumIsSet(true); + } + if (incoming.get(7)) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/CaptchaTask.java b/app/src/main/java/org/pyload/thrift/CaptchaTask.java index 955cef2..b9fd55b 100644 --- a/app/src/main/java/org/pyload/thrift/CaptchaTask.java +++ b/app/src/main/java/org/pyload/thrift/CaptchaTask.java @@ -1,692 +1,756 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + +import java.nio.ByteBuffer; import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.Arrays; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class CaptchaTask implements org.apache.thrift.TBase<CaptchaTask, CaptchaTask._Fields>, java.io.Serializable, Cloneable, Comparable<CaptchaTask>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CaptchaTask"); + + private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I16, (short) 1); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short) 3); + private static final org.apache.thrift.protocol.TField RESULT_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("resultType", org.apache.thrift.protocol.TType.STRING, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new CaptchaTaskStandardSchemeFactory()); + schemes.put(TupleScheme.class, new CaptchaTaskTupleSchemeFactory()); + } + + public short tid; // required + public ByteBuffer data; // required + public String type; // required + public String resultType; // required -public class CaptchaTask implements org.apache.thrift.TBase<CaptchaTask, CaptchaTask._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("CaptchaTask"); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(new Short(tid).intValue()); + out.writeInt(data != null ? 1 : 0); + if (data != null) { + out.writeByteArray(data.array(), data.position() + data.arrayOffset(), data.limit() - data.position()); + } + out.writeString(type); + out.writeString(resultType); + } + + @Override + public int describeContents() { + return 0; + } + + public CaptchaTask(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.tid = (short) in.readInt(); + if (in.readInt() == 1) { + this.data = ByteBuffer.wrap(in.createByteArray()); + } + this.type = in.readString(); + this.resultType = in.readString(); + } + + public static final android.os.Parcelable.Creator<CaptchaTask> CREATOR = new android.os.Parcelable.Creator<CaptchaTask>() { + @Override + public CaptchaTask[] newArray(int size) { + return new CaptchaTask[size]; + } + + @Override + public CaptchaTask createFromParcel(android.os.Parcel in) { + return new CaptchaTask(in); + } + }; - private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I16, (short)1); - private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField RESULT_TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("resultType", org.apache.thrift.protocol.TType.STRING, (short)4); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TID((short) 1, "tid"), + DATA((short) 2, "data"), + TYPE((short) 3, "type"), + RESULT_TYPE((short) 4, "resultType"); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new CaptchaTaskStandardSchemeFactory()); - schemes.put(TupleScheme.class, new CaptchaTaskTupleSchemeFactory()); - } + 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: // TID + return TID; + case 2: // DATA + return DATA; + case 3: // TYPE + return TYPE; + case 4: // RESULT_TYPE + return RESULT_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 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 tid; // required - public ByteBuffer data; // required - public String type; // required - public String resultType; // required + public short getThriftFieldId() { + return _thriftId; + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - TID((short)1, "tid"), - DATA((short)2, "data"), - TYPE((short)3, "type"), - RESULT_TYPE((short)4, "resultType"); + public String getFieldName() { + return _fieldName; + } + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + // isset id assignments + private static final int __TID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.RESULT_TYPE, new org.apache.thrift.meta_data.FieldMetaData("resultType", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CaptchaTask.class, metaDataMap); + } + + public CaptchaTask() { + } + + public CaptchaTask( + short tid, + ByteBuffer data, + String type, + String resultType) { + this(); + this.tid = tid; + setTidIsSet(true); + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + this.type = type; + this.resultType = resultType; } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // TID - return TID; - case 2: // DATA - return DATA; - case 3: // TYPE - return TYPE; - case 4: // RESULT_TYPE - return RESULT_TYPE; - default: - return null; - } + public CaptchaTask(CaptchaTask other) { + __isset_bitfield = other.__isset_bitfield; + this.tid = other.tid; + if (other.isSetData()) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); + } + if (other.isSetType()) { + this.type = other.type; + } + if (other.isSetResultType()) { + this.resultType = other.resultType; + } } - /** - * 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; + public CaptchaTask deepCopy() { + return new CaptchaTask(this); } - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __TID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, - 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.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.RESULT_TYPE, new org.apache.thrift.meta_data.FieldMetaData("resultType", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(CaptchaTask.class, metaDataMap); - } - - public CaptchaTask() { - } - - public CaptchaTask( - short tid, - ByteBuffer data, - String type, - String resultType) - { - this(); - this.tid = tid; - setTidIsSet(true); - this.data = data; - this.type = type; - this.resultType = resultType; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public CaptchaTask(CaptchaTask other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.tid = other.tid; - if (other.isSetData()) { - this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); -; - } - if (other.isSetType()) { - this.type = other.type; - } - if (other.isSetResultType()) { - this.resultType = other.resultType; - } - } - - public CaptchaTask deepCopy() { - return new CaptchaTask(this); - } - - @Override - public void clear() { - setTidIsSet(false); - this.tid = 0; - this.data = null; - this.type = null; - this.resultType = null; - } - - public short getTid() { - return this.tid; - } - - public CaptchaTask setTid(short tid) { - this.tid = tid; - setTidIsSet(true); - return this; - } - - public void unsetTid() { - __isset_bit_vector.clear(__TID_ISSET_ID); - } - - /** Returns true if field tid is set (has been assigned a value) and false otherwise */ - public boolean isSetTid() { - return __isset_bit_vector.get(__TID_ISSET_ID); - } - - public void setTidIsSet(boolean value) { - __isset_bit_vector.set(__TID_ISSET_ID, value); - } - - public byte[] getData() { - setData(org.apache.thrift.TBaseHelper.rightSize(data)); - return data == null ? null : data.array(); - } - - public ByteBuffer bufferForData() { - return data; - } - - public CaptchaTask setData(byte[] data) { - setData(data == null ? (ByteBuffer)null : ByteBuffer.wrap(data)); - return this; - } - - public CaptchaTask setData(ByteBuffer data) { - this.data = data; - return this; - } - - public void unsetData() { - this.data = null; - } - - /** Returns true if field data is set (has been assigned a value) and false otherwise */ - public boolean isSetData() { - return this.data != null; - } - - public void setDataIsSet(boolean value) { - if (!value) { - this.data = null; - } - } - - public String getType() { - return this.type; - } - - public CaptchaTask setType(String type) { - this.type = type; - return this; - } - - public void unsetType() { - this.type = null; - } - - /** Returns true if field type is set (has been assigned a value) and false otherwise */ - public boolean isSetType() { - return this.type != null; - } - - public void setTypeIsSet(boolean value) { - if (!value) { - this.type = null; - } - } - - public String getResultType() { - return this.resultType; - } - - public CaptchaTask setResultType(String resultType) { - this.resultType = resultType; - return this; - } - - public void unsetResultType() { - this.resultType = null; - } - - /** Returns true if field resultType is set (has been assigned a value) and false otherwise */ - public boolean isSetResultType() { - return this.resultType != null; - } - - public void setResultTypeIsSet(boolean value) { - if (!value) { - this.resultType = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case TID: - if (value == null) { - unsetTid(); - } else { - setTid((Short)value); - } - break; - - case DATA: - if (value == null) { - unsetData(); - } else { - setData((ByteBuffer)value); - } - break; - - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((String)value); - } - break; - - case RESULT_TYPE: - if (value == null) { - unsetResultType(); - } else { - setResultType((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case TID: - return Short.valueOf(getTid()); - - case DATA: - return getData(); - - case TYPE: - return getType(); - - case RESULT_TYPE: - return getResultType(); - - } - 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 TID: - return isSetTid(); - case DATA: - return isSetData(); - case TYPE: - return isSetType(); - case RESULT_TYPE: - return isSetResultType(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof CaptchaTask) - return this.equals((CaptchaTask)that); - return false; - } - - public boolean equals(CaptchaTask that) { - if (that == null) - return false; - - boolean this_present_tid = true; - boolean that_present_tid = true; - if (this_present_tid || that_present_tid) { - if (!(this_present_tid && that_present_tid)) - return false; - if (this.tid != that.tid) - return false; + @Override + public void clear() { + setTidIsSet(false); + this.tid = 0; + this.data = null; + this.type = null; + this.resultType = null; } - boolean this_present_data = true && this.isSetData(); - boolean that_present_data = true && that.isSetData(); - if (this_present_data || that_present_data) { - if (!(this_present_data && that_present_data)) - return false; - if (!this.data.equals(that.data)) - return false; + public short getTid() { + return this.tid; } - 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.equals(that.type)) - return false; + public CaptchaTask setTid(short tid) { + this.tid = tid; + setTidIsSet(true); + return this; } - boolean this_present_resultType = true && this.isSetResultType(); - boolean that_present_resultType = true && that.isSetResultType(); - if (this_present_resultType || that_present_resultType) { - if (!(this_present_resultType && that_present_resultType)) - return false; - if (!this.resultType.equals(that.resultType)) + public void unsetTid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TID_ISSET_ID); + } + + /** Returns true if field tid is set (has been assigned a value) and false otherwise */ + public boolean isSetTid() { + return EncodingUtils.testBit(__isset_bitfield, __TID_ISSET_ID); + } + + public void setTidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TID_ISSET_ID, value); + } + + public byte[] getData() { + setData(org.apache.thrift.TBaseHelper.rightSize(data)); + return data == null ? null : data.array(); + } + + public ByteBuffer bufferForData() { + return org.apache.thrift.TBaseHelper.copyBinary(data); + } + + public CaptchaTask setData(byte[] data) { + this.data = data == null ? (ByteBuffer) null : ByteBuffer.wrap(Arrays.copyOf(data, data.length)); + return this; + } + + public CaptchaTask setData(ByteBuffer data) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + return this; + } + + public void unsetData() { + this.data = null; + } + + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } + + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } + + public String getType() { + return this.type; + } + + public CaptchaTask setType(String type) { + this.type = type; + return this; + } + + public void unsetType() { + this.type = null; + } + + /** Returns true if field type is set (has been assigned a value) and false otherwise */ + public boolean isSetType() { + return this.type != null; + } + + public void setTypeIsSet(boolean value) { + if (!value) { + this.type = null; + } + } + + public String getResultType() { + return this.resultType; + } + + public CaptchaTask setResultType(String resultType) { + this.resultType = resultType; + return this; + } + + public void unsetResultType() { + this.resultType = null; + } + + /** Returns true if field resultType is set (has been assigned a value) and false otherwise */ + public boolean isSetResultType() { + return this.resultType != null; + } + + public void setResultTypeIsSet(boolean value) { + if (!value) { + this.resultType = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TID: + if (value == null) { + unsetTid(); + } else { + setTid((Short) value); + } + break; + + case DATA: + if (value == null) { + unsetData(); + } else { + setData((ByteBuffer) value); + } + break; + + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((String) value); + } + break; + + case RESULT_TYPE: + if (value == null) { + unsetResultType(); + } else { + setResultType((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case TID: + return getTid(); + + case DATA: + return getData(); + + case TYPE: + return getType(); + + case RESULT_TYPE: + return getResultType(); + + } + 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 TID: + return isSetTid(); + case DATA: + return isSetData(); + case TYPE: + return isSetType(); + case RESULT_TYPE: + return isSetResultType(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof CaptchaTask) + return this.equals((CaptchaTask) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(CaptchaTask other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - CaptchaTask typedOther = (CaptchaTask)other; - - lastComparison = Boolean.valueOf(isSetTid()).compareTo(typedOther.isSetTid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, typedOther.tid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetData()).compareTo(typedOther.isSetData()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetData()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, typedOther.data); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetResultType()).compareTo(typedOther.isSetResultType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetResultType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resultType, typedOther.resultType); - 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("CaptchaTask("); - boolean first = true; - - sb.append("tid:"); - sb.append(this.tid); - first = false; - if (!first) sb.append(", "); - sb.append("data:"); - if (this.data == null) { - sb.append("null"); - } else { - org.apache.thrift.TBaseHelper.toString(this.data, sb); - } - first = false; - if (!first) sb.append(", "); - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - if (!first) sb.append(", "); - sb.append("resultType:"); - if (this.resultType == null) { - sb.append("null"); - } else { - sb.append(this.resultType); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class CaptchaTaskStandardSchemeFactory implements SchemeFactory { - public CaptchaTaskStandardScheme getScheme() { - return new CaptchaTaskStandardScheme(); - } - } - - private static class CaptchaTaskStandardScheme extends StandardScheme<CaptchaTask> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, CaptchaTask 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: // TID - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.tid = iprot.readI16(); - struct.setTidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + public boolean equals(CaptchaTask that) { + if (that == null) + return false; + + boolean this_present_tid = true; + boolean that_present_tid = true; + if (this_present_tid || that_present_tid) { + if (!(this_present_tid && that_present_tid)) + return false; + if (this.tid != that.tid) + return false; + } + + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + 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.equals(that.type)) + return false; + } + + boolean this_present_resultType = true && this.isSetResultType(); + boolean that_present_resultType = true && that.isSetResultType(); + if (this_present_resultType || that_present_resultType) { + if (!(this_present_resultType && that_present_resultType)) + return false; + if (!this.resultType.equals(that.resultType)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_tid = true; + list.add(present_tid); + if (present_tid) + list.add(tid); + + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type); + + boolean present_resultType = true && (isSetResultType()); + list.add(present_resultType); + if (present_resultType) + list.add(resultType); + + return list.hashCode(); + } + + @Override + public int compareTo(CaptchaTask other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetTid()).compareTo(other.isSetTid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, other.tid); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // DATA - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // RESULT_TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.resultType = iprot.readString(); - struct.setResultTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetResultType()).compareTo(other.isSetResultType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResultType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.resultType, other.resultType); + if (lastComparison != 0) { + return lastComparison; } - 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, CaptchaTask struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(TID_FIELD_DESC); - oprot.writeI16(struct.tid); - oprot.writeFieldEnd(); - if (struct.data != null) { - oprot.writeFieldBegin(DATA_FIELD_DESC); - oprot.writeBinary(struct.data); - oprot.writeFieldEnd(); - } - if (struct.type != null) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeString(struct.type); - oprot.writeFieldEnd(); - } - if (struct.resultType != null) { - oprot.writeFieldBegin(RESULT_TYPE_FIELD_DESC); - oprot.writeString(struct.resultType); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class CaptchaTaskTupleSchemeFactory implements SchemeFactory { - public CaptchaTaskTupleScheme getScheme() { - return new CaptchaTaskTupleScheme(); - } - } - - private static class CaptchaTaskTupleScheme extends TupleScheme<CaptchaTask> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, CaptchaTask struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetTid()) { - optionals.set(0); - } - if (struct.isSetData()) { - optionals.set(1); - } - if (struct.isSetType()) { - optionals.set(2); - } - if (struct.isSetResultType()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetTid()) { - oprot.writeI16(struct.tid); - } - if (struct.isSetData()) { - oprot.writeBinary(struct.data); - } - if (struct.isSetType()) { - oprot.writeString(struct.type); - } - if (struct.isSetResultType()) { - oprot.writeString(struct.resultType); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, CaptchaTask struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.tid = iprot.readI16(); - struct.setTidIsSet(true); - } - if (incoming.get(1)) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(true); - } - if (incoming.get(2)) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } - if (incoming.get(3)) { - struct.resultType = iprot.readString(); - struct.setResultTypeIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("CaptchaTask("); + boolean first = true; + + sb.append("tid:"); + sb.append(this.tid); + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.data, sb); + } + first = false; + if (!first) sb.append(", "); + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + if (!first) sb.append(", "); + sb.append("resultType:"); + if (this.resultType == null) { + sb.append("null"); + } else { + sb.append(this.resultType); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 CaptchaTaskStandardSchemeFactory implements SchemeFactory { + public CaptchaTaskStandardScheme getScheme() { + return new CaptchaTaskStandardScheme(); + } + } + + private static class CaptchaTaskStandardScheme extends StandardScheme<CaptchaTask> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, CaptchaTask 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: // TID + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.tid = iprot.readI16(); + struct.setTidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // RESULT_TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.resultType = iprot.readString(); + struct.setResultTypeIsSet(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, CaptchaTask struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TID_FIELD_DESC); + oprot.writeI16(struct.tid); + oprot.writeFieldEnd(); + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + oprot.writeBinary(struct.data); + oprot.writeFieldEnd(); + } + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeString(struct.type); + oprot.writeFieldEnd(); + } + if (struct.resultType != null) { + oprot.writeFieldBegin(RESULT_TYPE_FIELD_DESC); + oprot.writeString(struct.resultType); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class CaptchaTaskTupleSchemeFactory implements SchemeFactory { + public CaptchaTaskTupleScheme getScheme() { + return new CaptchaTaskTupleScheme(); + } + } + + private static class CaptchaTaskTupleScheme extends TupleScheme<CaptchaTask> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, CaptchaTask struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTid()) { + optionals.set(0); + } + if (struct.isSetData()) { + optionals.set(1); + } + if (struct.isSetType()) { + optionals.set(2); + } + if (struct.isSetResultType()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetTid()) { + oprot.writeI16(struct.tid); + } + if (struct.isSetData()) { + oprot.writeBinary(struct.data); + } + if (struct.isSetType()) { + oprot.writeString(struct.type); + } + if (struct.isSetResultType()) { + oprot.writeString(struct.resultType); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, CaptchaTask struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.tid = iprot.readI16(); + struct.setTidIsSet(true); + } + if (incoming.get(1)) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(true); + } + if (incoming.get(2)) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } + if (incoming.get(3)) { + struct.resultType = iprot.readString(); + struct.setResultTypeIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ConfigItem.java b/app/src/main/java/org/pyload/thrift/ConfigItem.java index fef60db..d2038e6 100644 --- a/app/src/main/java/org/pyload/thrift/ConfigItem.java +++ b/app/src/main/java/org/pyload/thrift/ConfigItem.java @@ -1,682 +1,746 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class ConfigItem implements org.apache.thrift.TBase<ConfigItem, ConfigItem._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ConfigItem"); - - 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 DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", 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 TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short)4); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ConfigItemStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ConfigItemTupleSchemeFactory()); - } - - public String name; // required - public String description; // required - public String value; // required - public String type; // 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"), - DESCRIPTION((short)2, "description"), - VALUE((short)3, "value"), - TYPE((short)4, "type"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ConfigItem implements org.apache.thrift.TBase<ConfigItem, ConfigItem._Fields>, java.io.Serializable, Cloneable, Comparable<ConfigItem>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ConfigItem"); + + 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 DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", 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 TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.STRING, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new ConfigItemStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ConfigItemTupleSchemeFactory()); + } + + public String name; // required + public String description; // required + public String value; // required + public String type; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(name); + out.writeString(description); + out.writeString(value); + out.writeString(type); + } + + @Override + public int describeContents() { + return 0; + } + + public ConfigItem(android.os.Parcel in) { + this.name = in.readString(); + this.description = in.readString(); + this.value = in.readString(); + this.type = in.readString(); + } + + public static final android.os.Parcelable.Creator<ConfigItem> CREATOR = new android.os.Parcelable.Creator<ConfigItem>() { + @Override + public ConfigItem[] newArray(int size) { + return new ConfigItem[size]; + } + + @Override + public ConfigItem createFromParcel(android.os.Parcel in) { + return new ConfigItem(in); + } + }; + + /** + * 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"), + DESCRIPTION((short) 2, "description"), + VALUE((short) 3, "value"), + TYPE((short) 4, "type"); + + 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: // DESCRIPTION + return DESCRIPTION; + case 3: // VALUE + return VALUE; + case 4: // 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + 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))); + tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ConfigItem.class, metaDataMap); + } + + public ConfigItem() { + } + + public ConfigItem( + String name, + String description, + String value, + String type) { + this(); + this.name = name; + this.description = description; + this.value = value; + this.type = type; } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // NAME - return NAME; - case 2: // DESCRIPTION - return DESCRIPTION; - case 3: // VALUE - return VALUE; - case 4: // TYPE - return TYPE; - default: - return null; - } + public ConfigItem(ConfigItem other) { + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetDescription()) { + this.description = other.description; + } + if (other.isSetValue()) { + this.value = other.value; + } + if (other.isSetType()) { + this.type = other.type; + } + } + + public ConfigItem deepCopy() { + return new ConfigItem(this); + } + + @Override + public void clear() { + this.name = null; + this.description = null; + this.value = null; + this.type = null; + } + + public String getName() { + return this.name; + } + + public ConfigItem setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * Returns true if field name is set (has been assigned a value) and false otherwise */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getDescription() { + return this.description; + } + + public ConfigItem setDescription(String description) { + this.description = description; + return this; + } + + public void unsetDescription() { + this.description = null; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Returns true if field description is set (has been assigned a value) and false otherwise */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - 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))); - tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ConfigItem.class, metaDataMap); - } - - public ConfigItem() { - } - - public ConfigItem( - String name, - String description, - String value, - String type) - { - this(); - this.name = name; - this.description = description; - this.value = value; - this.type = type; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public ConfigItem(ConfigItem other) { - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetDescription()) { - this.description = other.description; - } - if (other.isSetValue()) { - this.value = other.value; - } - if (other.isSetType()) { - this.type = other.type; - } - } - - public ConfigItem deepCopy() { - return new ConfigItem(this); - } - - @Override - public void clear() { - this.name = null; - this.description = null; - this.value = null; - this.type = null; - } - - public String getName() { - return this.name; - } - - public ConfigItem setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getDescription() { - return this.description; - } - - public ConfigItem setDescription(String description) { - this.description = description; - return this; - } - - public void unsetDescription() { - this.description = null; - } - - /** Returns true if field description is set (has been assigned a value) and false otherwise */ - public boolean isSetDescription() { - return this.description != null; - } - - public void setDescriptionIsSet(boolean value) { - if (!value) { - this.description = null; - } - } - - public String getValue() { - return this.value; - } - - public ConfigItem setValue(String value) { - this.value = 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 String getType() { - return this.type; - } - - public ConfigItem setType(String type) { - this.type = type; - return this; - } - - public void unsetType() { - this.type = null; - } - - /** Returns true if field type is set (has been assigned a value) and false otherwise */ - public boolean isSetType() { - return this.type != null; - } - - public void setTypeIsSet(boolean value) { - if (!value) { - this.type = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case DESCRIPTION: - if (value == null) { - unsetDescription(); - } else { - setDescription((String)value); - } - break; - - case VALUE: - if (value == null) { - unsetValue(); - } else { - setValue((String)value); - } - break; - - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case NAME: - return getName(); - - case DESCRIPTION: - return getDescription(); - - case VALUE: - return getValue(); - - case TYPE: - return getType(); - - } - 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 DESCRIPTION: - return isSetDescription(); - case VALUE: - return isSetValue(); - case TYPE: - return isSetType(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ConfigItem) - return this.equals((ConfigItem)that); - return false; - } - - public boolean equals(ConfigItem 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; + public boolean isSetDescription() { + return this.description != null; } - boolean this_present_description = true && this.isSetDescription(); - boolean that_present_description = true && that.isSetDescription(); - if (this_present_description || that_present_description) { - if (!(this_present_description && that_present_description)) - return false; - if (!this.description.equals(that.description)) - return false; + public void setDescriptionIsSet(boolean value) { + if (!value) { + this.description = null; + } } - 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; + public String getValue() { + return this.value; } - 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.equals(that.type)) + public ConfigItem setValue(String value) { + this.value = 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 String getType() { + return this.type; + } + + public ConfigItem setType(String type) { + this.type = type; + return this; + } + + public void unsetType() { + this.type = null; + } + + /** + * Returns true if field type is set (has been assigned a value) and false otherwise + */ + public boolean isSetType() { + return this.type != null; + } + + public void setTypeIsSet(boolean value) { + if (!value) { + this.type = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case DESCRIPTION: + if (value == null) { + unsetDescription(); + } else { + setDescription((String) value); + } + break; + + case VALUE: + if (value == null) { + unsetValue(); + } else { + setValue((String) value); + } + break; + + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case DESCRIPTION: + return getDescription(); + + case VALUE: + return getValue(); + + case TYPE: + return getType(); + + } + 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 DESCRIPTION: + return isSetDescription(); + case VALUE: + return isSetValue(); + case TYPE: + return isSetType(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ConfigItem) + return this.equals((ConfigItem) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(ConfigItem other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - ConfigItem typedOther = (ConfigItem)other; - - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDescription()).compareTo(typedOther.isSetDescription()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDescription()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, typedOther.description); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetValue()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); - 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("ConfigItem("); - boolean first = true; - - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("description:"); - if (this.description == null) { - sb.append("null"); - } else { - sb.append(this.description); - } - first = false; - if (!first) sb.append(", "); - sb.append("value:"); - if (this.value == null) { - sb.append("null"); - } else { - sb.append(this.value); - } - first = false; - if (!first) sb.append(", "); - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - 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.getMessage()); - } - } - - private static class ConfigItemStandardSchemeFactory implements SchemeFactory { - public ConfigItemStandardScheme getScheme() { - return new ConfigItemStandardScheme(); - } - } - - private static class ConfigItemStandardScheme extends StandardScheme<ConfigItem> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ConfigItem 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); + public boolean equals(ConfigItem 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_description = true && this.isSetDescription(); + boolean that_present_description = true && that.isSetDescription(); + if (this_present_description || that_present_description) { + if (!(this_present_description && that_present_description)) + return false; + if (!this.description.equals(that.description)) + 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_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.equals(that.type)) + 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_description = true && (isSetDescription()); + list.add(present_description); + if (present_description) + list.add(description); + + boolean present_value = true && (isSetValue()); + list.add(present_value); + if (present_value) + list.add(value); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type); + + return list.hashCode(); + } + + @Override + public int compareTo(ConfigItem 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; } - break; - case 2: // DESCRIPTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.description = iprot.readString(); - struct.setDescriptionIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDescription()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // VALUE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.value = iprot.readString(); - struct.setValueIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetValue()).compareTo(other.isSetValue()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetValue()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, other.value); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; } - 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, ConfigItem 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.description != null) { - oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); - oprot.writeString(struct.description); - oprot.writeFieldEnd(); - } - if (struct.value != null) { - oprot.writeFieldBegin(VALUE_FIELD_DESC); - oprot.writeString(struct.value); - oprot.writeFieldEnd(); - } - if (struct.type != null) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeString(struct.type); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class ConfigItemTupleSchemeFactory implements SchemeFactory { - public ConfigItemTupleScheme getScheme() { - return new ConfigItemTupleScheme(); - } - } - - private static class ConfigItemTupleScheme extends TupleScheme<ConfigItem> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ConfigItem struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetName()) { - optionals.set(0); - } - if (struct.isSetDescription()) { - optionals.set(1); - } - if (struct.isSetValue()) { - optionals.set(2); - } - if (struct.isSetType()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetDescription()) { - oprot.writeString(struct.description); - } - if (struct.isSetValue()) { - oprot.writeString(struct.value); - } - if (struct.isSetType()) { - oprot.writeString(struct.type); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, ConfigItem struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(1)) { - struct.description = iprot.readString(); - struct.setDescriptionIsSet(true); - } - if (incoming.get(2)) { - struct.value = iprot.readString(); - struct.setValueIsSet(true); - } - if (incoming.get(3)) { - struct.type = iprot.readString(); - struct.setTypeIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("ConfigItem("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("description:"); + if (this.description == null) { + sb.append("null"); + } else { + sb.append(this.description); + } + first = false; + if (!first) sb.append(", "); + sb.append("value:"); + if (this.value == null) { + sb.append("null"); + } else { + sb.append(this.value); + } + first = false; + if (!first) sb.append(", "); + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class ConfigItemStandardSchemeFactory implements SchemeFactory { + public ConfigItemStandardScheme getScheme() { + return new ConfigItemStandardScheme(); + } + } + + private static class ConfigItemStandardScheme extends StandardScheme<ConfigItem> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ConfigItem 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: // DESCRIPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(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.readString(); + struct.setValueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.type = iprot.readString(); + 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, ConfigItem 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.description != null) { + oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); + oprot.writeString(struct.description); + oprot.writeFieldEnd(); + } + if (struct.value != null) { + oprot.writeFieldBegin(VALUE_FIELD_DESC); + oprot.writeString(struct.value); + oprot.writeFieldEnd(); + } + if (struct.type != null) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeString(struct.type); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ConfigItemTupleSchemeFactory implements SchemeFactory { + public ConfigItemTupleScheme getScheme() { + return new ConfigItemTupleScheme(); + } + } + + private static class ConfigItemTupleScheme extends TupleScheme<ConfigItem> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ConfigItem struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetDescription()) { + optionals.set(1); + } + if (struct.isSetValue()) { + optionals.set(2); + } + if (struct.isSetType()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetDescription()) { + oprot.writeString(struct.description); + } + if (struct.isSetValue()) { + oprot.writeString(struct.value); + } + if (struct.isSetType()) { + oprot.writeString(struct.type); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ConfigItem struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } + if (incoming.get(2)) { + struct.value = iprot.readString(); + struct.setValueIsSet(true); + } + if (incoming.get(3)) { + struct.type = iprot.readString(); + struct.setTypeIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ConfigSection.java b/app/src/main/java/org/pyload/thrift/ConfigSection.java index cfa9752..cbcb432 100644 --- a/app/src/main/java/org/pyload/thrift/ConfigSection.java +++ b/app/src/main/java/org/pyload/thrift/ConfigSection.java @@ -1,739 +1,788 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class ConfigSection implements org.apache.thrift.TBase<ConfigSection, ConfigSection._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ConfigSection"); - - 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 DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField ITEMS_FIELD_DESC = new org.apache.thrift.protocol.TField("items", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField OUTLINE_FIELD_DESC = new org.apache.thrift.protocol.TField("outline", org.apache.thrift.protocol.TType.STRING, (short)4); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ConfigSectionStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ConfigSectionTupleSchemeFactory()); - } - - public String name; // required - public String description; // required - public List<ConfigItem> items; // required - public String outline; // 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"), - DESCRIPTION((short)2, "description"), - ITEMS((short)3, "items"), - OUTLINE((short)4, "outline"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ConfigSection implements org.apache.thrift.TBase<ConfigSection, ConfigSection._Fields>, java.io.Serializable, Cloneable, Comparable<ConfigSection>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ConfigSection"); + + 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 DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField ITEMS_FIELD_DESC = new org.apache.thrift.protocol.TField("items", org.apache.thrift.protocol.TType.LIST, (short) 3); + private static final org.apache.thrift.protocol.TField OUTLINE_FIELD_DESC = new org.apache.thrift.protocol.TField("outline", org.apache.thrift.protocol.TType.STRING, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new ConfigSectionStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ConfigSectionTupleSchemeFactory()); } - /** - * 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: // DESCRIPTION - return DESCRIPTION; - case 3: // ITEMS - return ITEMS; - case 4: // OUTLINE - return OUTLINE; - default: - return null; - } + public String name; // required + public String description; // required + public List<ConfigItem> items; // required + public String outline; // optional + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(name); + out.writeString(description); + out.writeTypedList(items); + out.writeString(outline); } - /** - * 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; + @Override + public int describeContents() { + return 0; + } + + public ConfigSection(android.os.Parcel in) { + this.name = in.readString(); + this.description = in.readString(); + this.items = new ArrayList<ConfigItem>(); + in.readTypedList(this.items, ConfigItem.CREATOR); + this.outline = in.readString(); + } + + public static final android.os.Parcelable.Creator<ConfigSection> CREATOR = new android.os.Parcelable.Creator<ConfigSection>() { + @Override + public ConfigSection[] newArray(int size) { + return new ConfigSection[size]; + } + + @Override + public ConfigSection createFromParcel(android.os.Parcel in) { + return new ConfigSection(in); + } + }; + + /** 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"), + DESCRIPTION((short) 2, "description"), + ITEMS((short) 3, "items"), + OUTLINE((short) 4, "outline"); + + 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: // DESCRIPTION + return DESCRIPTION; + case 3: // ITEMS + return ITEMS; + case 4: // OUTLINE + return OUTLINE; + 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.OUTLINE}; + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ITEMS, new org.apache.thrift.meta_data.FieldMetaData("items", 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, ConfigItem.class)))); + tmpMap.put(_Fields.OUTLINE, new org.apache.thrift.meta_data.FieldMetaData("outline", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ConfigSection.class, metaDataMap); + } + + public ConfigSection() { + } + + public ConfigSection( + String name, + String description, + List<ConfigItem> items) { + this(); + this.name = name; + this.description = description; + this.items = items; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - 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 _Fields optionals[] = {_Fields.OUTLINE}; - 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.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.ITEMS, new org.apache.thrift.meta_data.FieldMetaData("items", 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, ConfigItem.class)))); - tmpMap.put(_Fields.OUTLINE, new org.apache.thrift.meta_data.FieldMetaData("outline", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ConfigSection.class, metaDataMap); - } - - public ConfigSection() { - } - - public ConfigSection( - String name, - String description, - List<ConfigItem> items) - { - this(); - this.name = name; - this.description = description; - this.items = items; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public ConfigSection(ConfigSection other) { - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetDescription()) { - this.description = other.description; - } - if (other.isSetItems()) { - List<ConfigItem> __this__items = new ArrayList<ConfigItem>(); - for (ConfigItem other_element : other.items) { - __this__items.add(new ConfigItem(other_element)); - } - this.items = __this__items; - } - if (other.isSetOutline()) { - this.outline = other.outline; - } - } - - public ConfigSection deepCopy() { - return new ConfigSection(this); - } - - @Override - public void clear() { - this.name = null; - this.description = null; - this.items = null; - this.outline = null; - } - - public String getName() { - return this.name; - } - - public ConfigSection setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getDescription() { - return this.description; - } - - public ConfigSection setDescription(String description) { - this.description = description; - return this; - } - - public void unsetDescription() { - this.description = null; - } - - /** Returns true if field description is set (has been assigned a value) and false otherwise */ - public boolean isSetDescription() { - return this.description != null; - } - - public void setDescriptionIsSet(boolean value) { - if (!value) { - this.description = null; - } - } - - public int getItemsSize() { - return (this.items == null) ? 0 : this.items.size(); - } - - public java.util.Iterator<ConfigItem> getItemsIterator() { - return (this.items == null) ? null : this.items.iterator(); - } - - public void addToItems(ConfigItem elem) { - if (this.items == null) { - this.items = new ArrayList<ConfigItem>(); - } - this.items.add(elem); - } - - public List<ConfigItem> getItems() { - return this.items; - } - - public ConfigSection setItems(List<ConfigItem> items) { - this.items = items; - return this; - } - - public void unsetItems() { - this.items = null; - } - - /** Returns true if field items is set (has been assigned a value) and false otherwise */ - public boolean isSetItems() { - return this.items != null; - } - - public void setItemsIsSet(boolean value) { - if (!value) { - this.items = null; - } - } - - public String getOutline() { - return this.outline; - } - - public ConfigSection setOutline(String outline) { - this.outline = outline; - return this; - } - - public void unsetOutline() { - this.outline = null; - } - - /** Returns true if field outline is set (has been assigned a value) and false otherwise */ - public boolean isSetOutline() { - return this.outline != null; - } - - public void setOutlineIsSet(boolean value) { - if (!value) { - this.outline = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case DESCRIPTION: - if (value == null) { - unsetDescription(); - } else { - setDescription((String)value); - } - break; - - case ITEMS: - if (value == null) { - unsetItems(); - } else { - setItems((List<ConfigItem>)value); - } - break; - - case OUTLINE: - if (value == null) { - unsetOutline(); - } else { - setOutline((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case NAME: - return getName(); - - case DESCRIPTION: - return getDescription(); - - case ITEMS: - return getItems(); - - case OUTLINE: - return getOutline(); - - } - 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 DESCRIPTION: - return isSetDescription(); - case ITEMS: - return isSetItems(); - case OUTLINE: - return isSetOutline(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ConfigSection) - return this.equals((ConfigSection)that); - return false; - } - - public boolean equals(ConfigSection 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; + public ConfigSection(ConfigSection other) { + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetDescription()) { + this.description = other.description; + } + if (other.isSetItems()) { + List<ConfigItem> __this__items = new ArrayList<ConfigItem>(other.items.size()); + for (ConfigItem other_element : other.items) { + __this__items.add(new ConfigItem(other_element)); + } + this.items = __this__items; + } + if (other.isSetOutline()) { + this.outline = other.outline; + } } - boolean this_present_description = true && this.isSetDescription(); - boolean that_present_description = true && that.isSetDescription(); - if (this_present_description || that_present_description) { - if (!(this_present_description && that_present_description)) - return false; - if (!this.description.equals(that.description)) - return false; + public ConfigSection deepCopy() { + return new ConfigSection(this); } - boolean this_present_items = true && this.isSetItems(); - boolean that_present_items = true && that.isSetItems(); - if (this_present_items || that_present_items) { - if (!(this_present_items && that_present_items)) - return false; - if (!this.items.equals(that.items)) - return false; + @Override + public void clear() { + this.name = null; + this.description = null; + this.items = null; + this.outline = null; } - boolean this_present_outline = true && this.isSetOutline(); - boolean that_present_outline = true && that.isSetOutline(); - if (this_present_outline || that_present_outline) { - if (!(this_present_outline && that_present_outline)) - return false; - if (!this.outline.equals(that.outline)) + public String getName() { + return this.name; + } + + public ConfigSection setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getDescription() { + return this.description; + } + + public ConfigSection setDescription(String description) { + this.description = description; + return this; + } + + public void unsetDescription() { + this.description = null; + } + + /** Returns true if field description is set (has been assigned a value) and false otherwise */ + public boolean isSetDescription() { + return this.description != null; + } + + public void setDescriptionIsSet(boolean value) { + if (!value) { + this.description = null; + } + } + + public int getItemsSize() { + return (this.items == null) ? 0 : this.items.size(); + } + + public java.util.Iterator<ConfigItem> getItemsIterator() { + return (this.items == null) ? null : this.items.iterator(); + } + + public void addToItems(ConfigItem elem) { + if (this.items == null) { + this.items = new ArrayList<ConfigItem>(); + } + this.items.add(elem); + } + + public List<ConfigItem> getItems() { + return this.items; + } + + public ConfigSection setItems(List<ConfigItem> items) { + this.items = items; + return this; + } + + public void unsetItems() { + this.items = null; + } + + /** Returns true if field items is set (has been assigned a value) and false otherwise */ + public boolean isSetItems() { + return this.items != null; + } + + public void setItemsIsSet(boolean value) { + if (!value) { + this.items = null; + } + } + + public String getOutline() { + return this.outline; + } + + public ConfigSection setOutline(String outline) { + this.outline = outline; + return this; + } + + public void unsetOutline() { + this.outline = null; + } + + /** Returns true if field outline is set (has been assigned a value) and false otherwise */ + public boolean isSetOutline() { + return this.outline != null; + } + + public void setOutlineIsSet(boolean value) { + if (!value) { + this.outline = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case DESCRIPTION: + if (value == null) { + unsetDescription(); + } else { + setDescription((String) value); + } + break; + + case ITEMS: + if (value == null) { + unsetItems(); + } else { + setItems((List<ConfigItem>) value); + } + break; + + case OUTLINE: + if (value == null) { + unsetOutline(); + } else { + setOutline((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case DESCRIPTION: + return getDescription(); + + case ITEMS: + return getItems(); + + case OUTLINE: + return getOutline(); + + } + 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 DESCRIPTION: + return isSetDescription(); + case ITEMS: + return isSetItems(); + case OUTLINE: + return isSetOutline(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ConfigSection) + return this.equals((ConfigSection) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(ConfigSection other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - ConfigSection typedOther = (ConfigSection)other; - - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDescription()).compareTo(typedOther.isSetDescription()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDescription()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, typedOther.description); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetItems()).compareTo(typedOther.isSetItems()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetItems()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.items, typedOther.items); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOutline()).compareTo(typedOther.isSetOutline()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOutline()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.outline, typedOther.outline); - 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("ConfigSection("); - boolean first = true; - - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("description:"); - if (this.description == null) { - sb.append("null"); - } else { - sb.append(this.description); - } - first = false; - if (!first) sb.append(", "); - sb.append("items:"); - if (this.items == null) { - sb.append("null"); - } else { - sb.append(this.items); - } - first = false; - if (isSetOutline()) { - if (!first) sb.append(", "); - sb.append("outline:"); - if (this.outline == null) { - sb.append("null"); - } else { - sb.append(this.outline); - } - first = false; - } - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - 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.getMessage()); - } - } - - private static class ConfigSectionStandardSchemeFactory implements SchemeFactory { - public ConfigSectionStandardScheme getScheme() { - return new ConfigSectionStandardScheme(); - } - } - - private static class ConfigSectionStandardScheme extends StandardScheme<ConfigSection> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ConfigSection 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); + public boolean equals(ConfigSection 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_description = true && this.isSetDescription(); + boolean that_present_description = true && that.isSetDescription(); + if (this_present_description || that_present_description) { + if (!(this_present_description && that_present_description)) + return false; + if (!this.description.equals(that.description)) + return false; + } + + boolean this_present_items = true && this.isSetItems(); + boolean that_present_items = true && that.isSetItems(); + if (this_present_items || that_present_items) { + if (!(this_present_items && that_present_items)) + return false; + if (!this.items.equals(that.items)) + return false; + } + + boolean this_present_outline = true && this.isSetOutline(); + boolean that_present_outline = true && that.isSetOutline(); + if (this_present_outline || that_present_outline) { + if (!(this_present_outline && that_present_outline)) + return false; + if (!this.outline.equals(that.outline)) + 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_description = true && (isSetDescription()); + list.add(present_description); + if (present_description) + list.add(description); + + boolean present_items = true && (isSetItems()); + list.add(present_items); + if (present_items) + list.add(items); + + boolean present_outline = true && (isSetOutline()); + list.add(present_outline); + if (present_outline) + list.add(outline); + + return list.hashCode(); + } + + @Override + public int compareTo(ConfigSection 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(isSetDescription()).compareTo(other.isSetDescription()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDescription()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // DESCRIPTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.description = iprot.readString(); - struct.setDescriptionIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetItems()).compareTo(other.isSetItems()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetItems()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.items, other.items); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // ITEMS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list0 = iprot.readListBegin(); - struct.items = new ArrayList<ConfigItem>(_list0.size); - for (int _i1 = 0; _i1 < _list0.size; ++_i1) + } + lastComparison = Boolean.valueOf(isSetOutline()).compareTo(other.isSetOutline()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOutline()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.outline, other.outline); + 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("ConfigSection("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("description:"); + if (this.description == null) { + sb.append("null"); + } else { + sb.append(this.description); + } + first = false; + if (!first) sb.append(", "); + sb.append("items:"); + if (this.items == null) { + sb.append("null"); + } else { + sb.append(this.items); + } + first = false; + if (isSetOutline()) { + if (!first) sb.append(", "); + sb.append("outline:"); + if (this.outline == null) { + sb.append("null"); + } else { + sb.append(this.outline); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class ConfigSectionStandardSchemeFactory implements SchemeFactory { + public ConfigSectionStandardScheme getScheme() { + return new ConfigSectionStandardScheme(); + } + } + + private static class ConfigSectionStandardScheme extends StandardScheme<ConfigSection> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ConfigSection 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: // DESCRIPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // ITEMS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list0 = iprot.readListBegin(); + struct.items = new ArrayList<ConfigItem>(_list0.size); + ConfigItem _elem1; + for (int _i2 = 0; _i2 < _list0.size; ++_i2) { + _elem1 = new ConfigItem(); + _elem1.read(iprot); + struct.items.add(_elem1); + } + iprot.readListEnd(); + } + struct.setItemsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // OUTLINE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.outline = iprot.readString(); + struct.setOutlineIsSet(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, ConfigSection 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.description != null) { + oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); + oprot.writeString(struct.description); + oprot.writeFieldEnd(); + } + if (struct.items != null) { + oprot.writeFieldBegin(ITEMS_FIELD_DESC); { - ConfigItem _elem2; // required - _elem2 = new ConfigItem(); - _elem2.read(iprot); - struct.items.add(_elem2); + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.items.size())); + for (ConfigItem _iter3 : struct.items) { + _iter3.write(oprot); + } + oprot.writeListEnd(); } - iprot.readListEnd(); - } - struct.setItemsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + oprot.writeFieldEnd(); } - break; - case 4: // OUTLINE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.outline = iprot.readString(); - struct.setOutlineIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + if (struct.outline != null) { + if (struct.isSetOutline()) { + oprot.writeFieldBegin(OUTLINE_FIELD_DESC); + oprot.writeString(struct.outline); + oprot.writeFieldEnd(); + } } - 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, ConfigSection 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.description != null) { - oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); - oprot.writeString(struct.description); - oprot.writeFieldEnd(); - } - if (struct.items != null) { - oprot.writeFieldBegin(ITEMS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.items.size())); - for (ConfigItem _iter3 : struct.items) - { - _iter3.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - if (struct.outline != null) { - if (struct.isSetOutline()) { - oprot.writeFieldBegin(OUTLINE_FIELD_DESC); - oprot.writeString(struct.outline); - oprot.writeFieldEnd(); - } - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class ConfigSectionTupleSchemeFactory implements SchemeFactory { - public ConfigSectionTupleScheme getScheme() { - return new ConfigSectionTupleScheme(); - } - } - - private static class ConfigSectionTupleScheme extends TupleScheme<ConfigSection> { + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ConfigSection struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetName()) { - optionals.set(0); - } - if (struct.isSetDescription()) { - optionals.set(1); - } - if (struct.isSetItems()) { - optionals.set(2); - } - if (struct.isSetOutline()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetDescription()) { - oprot.writeString(struct.description); - } - if (struct.isSetItems()) { - { - oprot.writeI32(struct.items.size()); - for (ConfigItem _iter4 : struct.items) - { - _iter4.write(oprot); - } - } - } - if (struct.isSetOutline()) { - oprot.writeString(struct.outline); - } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, ConfigSection struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(1)) { - struct.description = iprot.readString(); - struct.setDescriptionIsSet(true); - } - if (incoming.get(2)) { - { - org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.items = new ArrayList<ConfigItem>(_list5.size); - for (int _i6 = 0; _i6 < _list5.size; ++_i6) - { - ConfigItem _elem7; // required - _elem7 = new ConfigItem(); - _elem7.read(iprot); - struct.items.add(_elem7); - } - } - struct.setItemsIsSet(true); - } - if (incoming.get(3)) { - struct.outline = iprot.readString(); - struct.setOutlineIsSet(true); - } - } - } + private static class ConfigSectionTupleSchemeFactory implements SchemeFactory { + public ConfigSectionTupleScheme getScheme() { + return new ConfigSectionTupleScheme(); + } + } + + private static class ConfigSectionTupleScheme extends TupleScheme<ConfigSection> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ConfigSection struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetDescription()) { + optionals.set(1); + } + if (struct.isSetItems()) { + optionals.set(2); + } + if (struct.isSetOutline()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetDescription()) { + oprot.writeString(struct.description); + } + if (struct.isSetItems()) { + { + oprot.writeI32(struct.items.size()); + for (ConfigItem _iter4 : struct.items) { + _iter4.write(oprot); + } + } + } + if (struct.isSetOutline()) { + oprot.writeString(struct.outline); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ConfigSection struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list5 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.items = new ArrayList<ConfigItem>(_list5.size); + ConfigItem _elem6; + for (int _i7 = 0; _i7 < _list5.size; ++_i7) { + _elem6 = new ConfigItem(); + _elem6.read(iprot); + struct.items.add(_elem6); + } + } + struct.setItemsIsSet(true); + } + if (incoming.get(3)) { + struct.outline = iprot.readString(); + struct.setOutlineIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/Destination.java b/app/src/main/java/org/pyload/thrift/Destination.java index 392ee26..e7fbf12 100644 --- a/app/src/main/java/org/pyload/thrift/Destination.java +++ b/app/src/main/java/org/pyload/thrift/Destination.java @@ -1,45 +1,42 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; -import java.util.Map; -import java.util.HashMap; -import org.apache.thrift.TEnum; - public enum Destination implements org.apache.thrift.TEnum { - Collector(0), - Queue(1); + Collector(0), + Queue(1); - private final int value; + private final int value; - private Destination(int value) { - this.value = value; - } + private Destination(int value) { + this.value = value; + } - /** - * Get the integer value of this enum value, as defined in the Thrift IDL. - */ - public int getValue() { - return 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. - */ - public static Destination findByValue(int value) { - switch (value) { - case 0: - return Collector; - case 1: - return Queue; - default: - return null; + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static Destination findByValue(int value) { + switch (value) { + case 0: + return Collector; + case 1: + return Queue; + default: + return null; + } } - } } diff --git a/app/src/main/java/org/pyload/thrift/DownloadInfo.java b/app/src/main/java/org/pyload/thrift/DownloadInfo.java index bb11054..759f04e 100644 --- a/app/src/main/java/org/pyload/thrift/DownloadInfo.java +++ b/app/src/main/java/org/pyload/thrift/DownloadInfo.java @@ -1,1855 +1,1997 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class DownloadInfo implements org.apache.thrift.TBase<DownloadInfo, DownloadInfo._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("DownloadInfo"); - - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField SPEED_FIELD_DESC = new org.apache.thrift.protocol.TField("speed", org.apache.thrift.protocol.TType.I64, (short)3); - private static final org.apache.thrift.protocol.TField ETA_FIELD_DESC = new org.apache.thrift.protocol.TField("eta", org.apache.thrift.protocol.TType.I32, (short)4); - private static final org.apache.thrift.protocol.TField FORMAT_ETA_FIELD_DESC = new org.apache.thrift.protocol.TField("format_eta", org.apache.thrift.protocol.TType.STRING, (short)5); - private static final org.apache.thrift.protocol.TField BLEFT_FIELD_DESC = new org.apache.thrift.protocol.TField("bleft", org.apache.thrift.protocol.TType.I64, (short)6); - private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short)7); - private static final org.apache.thrift.protocol.TField FORMAT_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("format_size", org.apache.thrift.protocol.TType.STRING, (short)8); - private static final org.apache.thrift.protocol.TField PERCENT_FIELD_DESC = new org.apache.thrift.protocol.TField("percent", org.apache.thrift.protocol.TType.BYTE, (short)9); - private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short)10); - private static final org.apache.thrift.protocol.TField STATUSMSG_FIELD_DESC = new org.apache.thrift.protocol.TField("statusmsg", org.apache.thrift.protocol.TType.STRING, (short)11); - private static final org.apache.thrift.protocol.TField FORMAT_WAIT_FIELD_DESC = new org.apache.thrift.protocol.TField("format_wait", org.apache.thrift.protocol.TType.STRING, (short)12); - private static final org.apache.thrift.protocol.TField WAIT_UNTIL_FIELD_DESC = new org.apache.thrift.protocol.TField("wait_until", org.apache.thrift.protocol.TType.I64, (short)13); - private static final org.apache.thrift.protocol.TField PACKAGE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("packageID", org.apache.thrift.protocol.TType.I32, (short)14); - private static final org.apache.thrift.protocol.TField PACKAGE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("packageName", org.apache.thrift.protocol.TType.STRING, (short)15); - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)16); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new DownloadInfoStandardSchemeFactory()); - schemes.put(TupleScheme.class, new DownloadInfoTupleSchemeFactory()); - } - - public int fid; // required - public String name; // required - public long speed; // required - public int eta; // required - public String format_eta; // required - public long bleft; // required - public long size; // required - public String format_size; // required - public byte percent; // required - /** - * - * @see DownloadStatus - */ - public DownloadStatus status; // required - public String statusmsg; // required - public String format_wait; // required - public long wait_until; // required - public int packageID; // required - public String packageName; // required - public String plugin; // 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 { - FID((short)1, "fid"), - NAME((short)2, "name"), - SPEED((short)3, "speed"), - ETA((short)4, "eta"), - FORMAT_ETA((short)5, "format_eta"), - BLEFT((short)6, "bleft"), - SIZE((short)7, "size"), - FORMAT_SIZE((short)8, "format_size"), - PERCENT((short)9, "percent"), +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class DownloadInfo implements org.apache.thrift.TBase<DownloadInfo, DownloadInfo._Fields>, java.io.Serializable, Cloneable, Comparable<DownloadInfo>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("DownloadInfo"); + + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField SPEED_FIELD_DESC = new org.apache.thrift.protocol.TField("speed", org.apache.thrift.protocol.TType.I64, (short) 3); + private static final org.apache.thrift.protocol.TField ETA_FIELD_DESC = new org.apache.thrift.protocol.TField("eta", org.apache.thrift.protocol.TType.I32, (short) 4); + private static final org.apache.thrift.protocol.TField FORMAT_ETA_FIELD_DESC = new org.apache.thrift.protocol.TField("format_eta", org.apache.thrift.protocol.TType.STRING, (short) 5); + private static final org.apache.thrift.protocol.TField BLEFT_FIELD_DESC = new org.apache.thrift.protocol.TField("bleft", org.apache.thrift.protocol.TType.I64, (short) 6); + private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short) 7); + private static final org.apache.thrift.protocol.TField FORMAT_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("format_size", org.apache.thrift.protocol.TType.STRING, (short) 8); + private static final org.apache.thrift.protocol.TField PERCENT_FIELD_DESC = new org.apache.thrift.protocol.TField("percent", org.apache.thrift.protocol.TType.BYTE, (short) 9); + private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short) 10); + private static final org.apache.thrift.protocol.TField STATUSMSG_FIELD_DESC = new org.apache.thrift.protocol.TField("statusmsg", org.apache.thrift.protocol.TType.STRING, (short) 11); + private static final org.apache.thrift.protocol.TField FORMAT_WAIT_FIELD_DESC = new org.apache.thrift.protocol.TField("format_wait", org.apache.thrift.protocol.TType.STRING, (short) 12); + private static final org.apache.thrift.protocol.TField WAIT_UNTIL_FIELD_DESC = new org.apache.thrift.protocol.TField("wait_until", org.apache.thrift.protocol.TType.I64, (short) 13); + private static final org.apache.thrift.protocol.TField PACKAGE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("packageID", org.apache.thrift.protocol.TType.I32, (short) 14); + private static final org.apache.thrift.protocol.TField PACKAGE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("packageName", org.apache.thrift.protocol.TType.STRING, (short) 15); + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 16); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new DownloadInfoStandardSchemeFactory()); + schemes.put(TupleScheme.class, new DownloadInfoTupleSchemeFactory()); + } + + public int fid; // required + public String name; // required + public long speed; // required + public int eta; // required + public String format_eta; // required + public long bleft; // required + public long size; // required + public String format_size; // required + public byte percent; // required /** - * + * * @see DownloadStatus */ - STATUS((short)10, "status"), - STATUSMSG((short)11, "statusmsg"), - FORMAT_WAIT((short)12, "format_wait"), - WAIT_UNTIL((short)13, "wait_until"), - PACKAGE_ID((short)14, "packageID"), - PACKAGE_NAME((short)15, "packageName"), - PLUGIN((short)16, "plugin"); + public DownloadStatus status; // required + public String statusmsg; // required + public String format_wait; // required + public long wait_until; // required + public int packageID; // required + public String packageName; // required + public String plugin; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(fid); + out.writeString(name); + out.writeLong(speed); + out.writeInt(eta); + out.writeString(format_eta); + out.writeLong(bleft); + out.writeLong(size); + out.writeString(format_size); + out.writeByte(percent); + out.writeInt(status.getValue()); + out.writeString(statusmsg); + out.writeString(format_wait); + out.writeLong(wait_until); + out.writeInt(packageID); + out.writeString(packageName); + out.writeString(plugin); + } + + @Override + public int describeContents() { + return 0; + } + + public DownloadInfo(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.fid = in.readInt(); + this.name = in.readString(); + this.speed = in.readLong(); + this.eta = in.readInt(); + this.format_eta = in.readString(); + this.bleft = in.readLong(); + this.size = in.readLong(); + this.format_size = in.readString(); + this.percent = in.readByte(); + this.status = DownloadStatus.findByValue(in.readInt()); + this.statusmsg = in.readString(); + this.format_wait = in.readString(); + this.wait_until = in.readLong(); + this.packageID = in.readInt(); + this.packageName = in.readString(); + this.plugin = in.readString(); + } + + public static final android.os.Parcelable.Creator<DownloadInfo> CREATOR = new android.os.Parcelable.Creator<DownloadInfo>() { + @Override + public DownloadInfo[] newArray(int size) { + return new DownloadInfo[size]; + } + + @Override + public DownloadInfo createFromParcel(android.os.Parcel in) { + return new DownloadInfo(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"), + NAME((short) 2, "name"), + SPEED((short) 3, "speed"), + ETA((short) 4, "eta"), + FORMAT_ETA((short) 5, "format_eta"), + BLEFT((short) 6, "bleft"), + SIZE((short) 7, "size"), + FORMAT_SIZE((short) 8, "format_size"), + PERCENT((short) 9, "percent"), + /** + * + * @see DownloadStatus + */ + STATUS((short) 10, "status"), + STATUSMSG((short) 11, "statusmsg"), + FORMAT_WAIT((short) 12, "format_wait"), + WAIT_UNTIL((short) 13, "wait_until"), + PACKAGE_ID((short) 14, "packageID"), + PACKAGE_NAME((short) 15, "packageName"), + PLUGIN((short) 16, "plugin"); + + 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: // FID + return FID; + case 2: // NAME + return NAME; + case 3: // SPEED + return SPEED; + case 4: // ETA + return ETA; + case 5: // FORMAT_ETA + return FORMAT_ETA; + case 6: // BLEFT + return BLEFT; + case 7: // SIZE + return SIZE; + case 8: // FORMAT_SIZE + return FORMAT_SIZE; + case 9: // PERCENT + return PERCENT; + case 10: // STATUS + return STATUS; + case 11: // STATUSMSG + return STATUSMSG; + case 12: // FORMAT_WAIT + return FORMAT_WAIT; + case 13: // WAIT_UNTIL + return WAIT_UNTIL; + case 14: // PACKAGE_ID + return PACKAGE_ID; + case 15: // PACKAGE_NAME + return PACKAGE_NAME; + case 16: // PLUGIN + return PLUGIN; + 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; + } + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private static final int __SPEED_ISSET_ID = 1; + private static final int __ETA_ISSET_ID = 2; + private static final int __BLEFT_ISSET_ID = 3; + private static final int __SIZE_ISSET_ID = 4; + private static final int __PERCENT_ISSET_ID = 5; + private static final int __WAIT_UNTIL_ISSET_ID = 6; + private static final int __PACKAGEID_ISSET_ID = 7; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.SPEED, new org.apache.thrift.meta_data.FieldMetaData("speed", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.ETA, new org.apache.thrift.meta_data.FieldMetaData("eta", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.FORMAT_ETA, new org.apache.thrift.meta_data.FieldMetaData("format_eta", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.BLEFT, new org.apache.thrift.meta_data.FieldMetaData("bleft", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.FORMAT_SIZE, new org.apache.thrift.meta_data.FieldMetaData("format_size", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PERCENT, new org.apache.thrift.meta_data.FieldMetaData("percent", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE, "Progress"))); + tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); + tmpMap.put(_Fields.STATUSMSG, new org.apache.thrift.meta_data.FieldMetaData("statusmsg", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.FORMAT_WAIT, new org.apache.thrift.meta_data.FieldMetaData("format_wait", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.WAIT_UNTIL, new org.apache.thrift.meta_data.FieldMetaData("wait_until", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.PACKAGE_ID, new org.apache.thrift.meta_data.FieldMetaData("packageID", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.PACKAGE_NAME, new org.apache.thrift.meta_data.FieldMetaData("packageName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DownloadInfo.class, metaDataMap); + } + + public DownloadInfo() { + } + + public DownloadInfo( + int fid, + String name, + long speed, + int eta, + String format_eta, + long bleft, + long size, + String format_size, + byte percent, + DownloadStatus status, + String statusmsg, + String format_wait, + long wait_until, + int packageID, + String packageName, + String plugin) { + this(); + this.fid = fid; + setFidIsSet(true); + this.name = name; + this.speed = speed; + setSpeedIsSet(true); + this.eta = eta; + setEtaIsSet(true); + this.format_eta = format_eta; + this.bleft = bleft; + setBleftIsSet(true); + this.size = size; + setSizeIsSet(true); + this.format_size = format_size; + this.percent = percent; + setPercentIsSet(true); + this.status = status; + this.statusmsg = statusmsg; + this.format_wait = format_wait; + this.wait_until = wait_until; + setWait_untilIsSet(true); + this.packageID = packageID; + setPackageIDIsSet(true); + this.packageName = packageName; + this.plugin = plugin; } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // FID - return FID; - case 2: // NAME - return NAME; - case 3: // SPEED - return SPEED; - case 4: // ETA - return ETA; - case 5: // FORMAT_ETA - return FORMAT_ETA; - case 6: // BLEFT - return BLEFT; - case 7: // SIZE - return SIZE; - case 8: // FORMAT_SIZE - return FORMAT_SIZE; - case 9: // PERCENT - return PERCENT; - case 10: // STATUS - return STATUS; - case 11: // STATUSMSG - return STATUSMSG; - case 12: // FORMAT_WAIT - return FORMAT_WAIT; - case 13: // WAIT_UNTIL - return WAIT_UNTIL; - case 14: // PACKAGE_ID - return PACKAGE_ID; - case 15: // PACKAGE_NAME - return PACKAGE_NAME; - case 16: // PLUGIN - return PLUGIN; - default: - return null; - } + public DownloadInfo(DownloadInfo other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; + if (other.isSetName()) { + this.name = other.name; + } + this.speed = other.speed; + this.eta = other.eta; + if (other.isSetFormat_eta()) { + this.format_eta = other.format_eta; + } + this.bleft = other.bleft; + this.size = other.size; + if (other.isSetFormat_size()) { + this.format_size = other.format_size; + } + this.percent = other.percent; + if (other.isSetStatus()) { + this.status = other.status; + } + if (other.isSetStatusmsg()) { + this.statusmsg = other.statusmsg; + } + if (other.isSetFormat_wait()) { + this.format_wait = other.format_wait; + } + this.wait_until = other.wait_until; + this.packageID = other.packageID; + if (other.isSetPackageName()) { + this.packageName = other.packageName; + } + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + } + + public DownloadInfo deepCopy() { + return new DownloadInfo(this); + } + + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + this.name = null; + setSpeedIsSet(false); + this.speed = 0; + setEtaIsSet(false); + this.eta = 0; + this.format_eta = null; + setBleftIsSet(false); + this.bleft = 0; + setSizeIsSet(false); + this.size = 0; + this.format_size = null; + setPercentIsSet(false); + this.percent = 0; + this.status = null; + this.statusmsg = null; + this.format_wait = null; + setWait_untilIsSet(false); + this.wait_until = 0; + setPackageIDIsSet(false); + this.packageID = 0; + this.packageName = null; + this.plugin = null; + } + + public int getFid() { + return this.fid; + } + + public DownloadInfo setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; + } + + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } + + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); + } + + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); + } + + public String getName() { + return this.name; + } + + public DownloadInfo 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 long getSpeed() { + return this.speed; + } + + public DownloadInfo setSpeed(long speed) { + this.speed = speed; + setSpeedIsSet(true); + return this; + } + + public void unsetSpeed() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SPEED_ISSET_ID); + } + + /** Returns true if field speed is set (has been assigned a value) and false otherwise */ + public boolean isSetSpeed() { + return EncodingUtils.testBit(__isset_bitfield, __SPEED_ISSET_ID); + } + + public void setSpeedIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SPEED_ISSET_ID, value); + } + + public int getEta() { + return this.eta; + } + + public DownloadInfo setEta(int eta) { + this.eta = eta; + setEtaIsSet(true); + return this; + } + + public void unsetEta() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ETA_ISSET_ID); + } + + /** Returns true if field eta is set (has been assigned a value) and false otherwise */ + public boolean isSetEta() { + return EncodingUtils.testBit(__isset_bitfield, __ETA_ISSET_ID); + } + + public void setEtaIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ETA_ISSET_ID, value); + } + + public String getFormat_eta() { + return this.format_eta; + } + + public DownloadInfo setFormat_eta(String format_eta) { + this.format_eta = format_eta; + return this; + } + + public void unsetFormat_eta() { + this.format_eta = null; + } + + /** Returns true if field format_eta is set (has been assigned a value) and false otherwise */ + public boolean isSetFormat_eta() { + return this.format_eta != null; + } + + public void setFormat_etaIsSet(boolean value) { + if (!value) { + this.format_eta = null; + } + } + + public long getBleft() { + return this.bleft; + } + + public DownloadInfo setBleft(long bleft) { + this.bleft = bleft; + setBleftIsSet(true); + return this; + } + + public void unsetBleft() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BLEFT_ISSET_ID); + } + + /** Returns true if field bleft is set (has been assigned a value) and false otherwise */ + public boolean isSetBleft() { + return EncodingUtils.testBit(__isset_bitfield, __BLEFT_ISSET_ID); + } + + public void setBleftIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BLEFT_ISSET_ID, value); + } + + public long getSize() { + return this.size; + } + + public DownloadInfo setSize(long size) { + this.size = size; + setSizeIsSet(true); + return this; + } + + public void unsetSize() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + /** Returns true if field size is set (has been assigned a value) and false otherwise */ + public boolean isSetSize() { + return EncodingUtils.testBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + public void setSizeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SIZE_ISSET_ID, value); + } + + public String getFormat_size() { + return this.format_size; + } + + public DownloadInfo setFormat_size(String format_size) { + this.format_size = format_size; + return this; + } + + public void unsetFormat_size() { + this.format_size = null; + } + + /** Returns true if field format_size is set (has been assigned a value) and false otherwise */ + public boolean isSetFormat_size() { + return this.format_size != null; + } + + public void setFormat_sizeIsSet(boolean value) { + if (!value) { + this.format_size = null; + } + } + + public byte getPercent() { + return this.percent; + } + + public DownloadInfo setPercent(byte percent) { + this.percent = percent; + setPercentIsSet(true); + return this; + } + + public void unsetPercent() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PERCENT_ISSET_ID); + } + + /** Returns true if field percent is set (has been assigned a value) and false otherwise */ + public boolean isSetPercent() { + return EncodingUtils.testBit(__isset_bitfield, __PERCENT_ISSET_ID); + } + + public void setPercentIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PERCENT_ISSET_ID, value); } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * + * @see DownloadStatus */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public DownloadStatus getStatus() { + return this.status; } /** - * Find the _Fields constant that matches name, or null if its not found. + * + * @see DownloadStatus */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private static final int __SPEED_ISSET_ID = 1; - private static final int __ETA_ISSET_ID = 2; - private static final int __BLEFT_ISSET_ID = 3; - private static final int __SIZE_ISSET_ID = 4; - private static final int __PERCENT_ISSET_ID = 5; - private static final int __WAIT_UNTIL_ISSET_ID = 6; - private static final int __PACKAGEID_ISSET_ID = 7; - private BitSet __isset_bit_vector = new BitSet(8); - 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.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.SPEED, new org.apache.thrift.meta_data.FieldMetaData("speed", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.ETA, new org.apache.thrift.meta_data.FieldMetaData("eta", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); - tmpMap.put(_Fields.FORMAT_ETA, new org.apache.thrift.meta_data.FieldMetaData("format_eta", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.BLEFT, new org.apache.thrift.meta_data.FieldMetaData("bleft", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.FORMAT_SIZE, new org.apache.thrift.meta_data.FieldMetaData("format_size", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PERCENT, new org.apache.thrift.meta_data.FieldMetaData("percent", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE , "Progress"))); - tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); - tmpMap.put(_Fields.STATUSMSG, new org.apache.thrift.meta_data.FieldMetaData("statusmsg", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.FORMAT_WAIT, new org.apache.thrift.meta_data.FieldMetaData("format_wait", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.WAIT_UNTIL, new org.apache.thrift.meta_data.FieldMetaData("wait_until", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.PACKAGE_ID, new org.apache.thrift.meta_data.FieldMetaData("packageID", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.PACKAGE_NAME, new org.apache.thrift.meta_data.FieldMetaData("packageName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(DownloadInfo.class, metaDataMap); - } - - public DownloadInfo() { - } - - public DownloadInfo( - int fid, - String name, - long speed, - int eta, - String format_eta, - long bleft, - long size, - String format_size, - byte percent, - DownloadStatus status, - String statusmsg, - String format_wait, - long wait_until, - int packageID, - String packageName, - String plugin) - { - this(); - this.fid = fid; - setFidIsSet(true); - this.name = name; - this.speed = speed; - setSpeedIsSet(true); - this.eta = eta; - setEtaIsSet(true); - this.format_eta = format_eta; - this.bleft = bleft; - setBleftIsSet(true); - this.size = size; - setSizeIsSet(true); - this.format_size = format_size; - this.percent = percent; - setPercentIsSet(true); - this.status = status; - this.statusmsg = statusmsg; - this.format_wait = format_wait; - this.wait_until = wait_until; - setWait_untilIsSet(true); - this.packageID = packageID; - setPackageIDIsSet(true); - this.packageName = packageName; - this.plugin = plugin; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public DownloadInfo(DownloadInfo other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - if (other.isSetName()) { - this.name = other.name; - } - this.speed = other.speed; - this.eta = other.eta; - if (other.isSetFormat_eta()) { - this.format_eta = other.format_eta; - } - this.bleft = other.bleft; - this.size = other.size; - if (other.isSetFormat_size()) { - this.format_size = other.format_size; - } - this.percent = other.percent; - if (other.isSetStatus()) { - this.status = other.status; - } - if (other.isSetStatusmsg()) { - this.statusmsg = other.statusmsg; - } - if (other.isSetFormat_wait()) { - this.format_wait = other.format_wait; - } - this.wait_until = other.wait_until; - this.packageID = other.packageID; - if (other.isSetPackageName()) { - this.packageName = other.packageName; - } - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - } - - public DownloadInfo deepCopy() { - return new DownloadInfo(this); - } - - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - this.name = null; - setSpeedIsSet(false); - this.speed = 0; - setEtaIsSet(false); - this.eta = 0; - this.format_eta = null; - setBleftIsSet(false); - this.bleft = 0; - setSizeIsSet(false); - this.size = 0; - this.format_size = null; - setPercentIsSet(false); - this.percent = 0; - this.status = null; - this.statusmsg = null; - this.format_wait = null; - setWait_untilIsSet(false); - this.wait_until = 0; - setPackageIDIsSet(false); - this.packageID = 0; - this.packageName = null; - this.plugin = null; - } - - public int getFid() { - return this.fid; - } - - public DownloadInfo setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; - } - - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } - - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } - - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } - - public String getName() { - return this.name; - } - - public DownloadInfo 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 long getSpeed() { - return this.speed; - } - - public DownloadInfo setSpeed(long speed) { - this.speed = speed; - setSpeedIsSet(true); - return this; - } - - public void unsetSpeed() { - __isset_bit_vector.clear(__SPEED_ISSET_ID); - } - - /** Returns true if field speed is set (has been assigned a value) and false otherwise */ - public boolean isSetSpeed() { - return __isset_bit_vector.get(__SPEED_ISSET_ID); - } - - public void setSpeedIsSet(boolean value) { - __isset_bit_vector.set(__SPEED_ISSET_ID, value); - } - - public int getEta() { - return this.eta; - } - - public DownloadInfo setEta(int eta) { - this.eta = eta; - setEtaIsSet(true); - return this; - } - - public void unsetEta() { - __isset_bit_vector.clear(__ETA_ISSET_ID); - } - - /** Returns true if field eta is set (has been assigned a value) and false otherwise */ - public boolean isSetEta() { - return __isset_bit_vector.get(__ETA_ISSET_ID); - } - - public void setEtaIsSet(boolean value) { - __isset_bit_vector.set(__ETA_ISSET_ID, value); - } - - public String getFormat_eta() { - return this.format_eta; - } - - public DownloadInfo setFormat_eta(String format_eta) { - this.format_eta = format_eta; - return this; - } - - public void unsetFormat_eta() { - this.format_eta = null; - } - - /** Returns true if field format_eta is set (has been assigned a value) and false otherwise */ - public boolean isSetFormat_eta() { - return this.format_eta != null; - } - - public void setFormat_etaIsSet(boolean value) { - if (!value) { - this.format_eta = null; - } - } - - public long getBleft() { - return this.bleft; - } - - public DownloadInfo setBleft(long bleft) { - this.bleft = bleft; - setBleftIsSet(true); - return this; - } - - public void unsetBleft() { - __isset_bit_vector.clear(__BLEFT_ISSET_ID); - } - - /** Returns true if field bleft is set (has been assigned a value) and false otherwise */ - public boolean isSetBleft() { - return __isset_bit_vector.get(__BLEFT_ISSET_ID); - } - - public void setBleftIsSet(boolean value) { - __isset_bit_vector.set(__BLEFT_ISSET_ID, value); - } - - public long getSize() { - return this.size; - } - - public DownloadInfo setSize(long size) { - this.size = size; - setSizeIsSet(true); - return this; - } - - public void unsetSize() { - __isset_bit_vector.clear(__SIZE_ISSET_ID); - } - - /** Returns true if field size is set (has been assigned a value) and false otherwise */ - public boolean isSetSize() { - return __isset_bit_vector.get(__SIZE_ISSET_ID); - } - - public void setSizeIsSet(boolean value) { - __isset_bit_vector.set(__SIZE_ISSET_ID, value); - } - - public String getFormat_size() { - return this.format_size; - } - - public DownloadInfo setFormat_size(String format_size) { - this.format_size = format_size; - return this; - } - - public void unsetFormat_size() { - this.format_size = null; - } - - /** Returns true if field format_size is set (has been assigned a value) and false otherwise */ - public boolean isSetFormat_size() { - return this.format_size != null; - } - - public void setFormat_sizeIsSet(boolean value) { - if (!value) { - this.format_size = null; - } - } - - public byte getPercent() { - return this.percent; - } - - public DownloadInfo setPercent(byte percent) { - this.percent = percent; - setPercentIsSet(true); - return this; - } - - public void unsetPercent() { - __isset_bit_vector.clear(__PERCENT_ISSET_ID); - } - - /** Returns true if field percent is set (has been assigned a value) and false otherwise */ - public boolean isSetPercent() { - return __isset_bit_vector.get(__PERCENT_ISSET_ID); - } - - public void setPercentIsSet(boolean value) { - __isset_bit_vector.set(__PERCENT_ISSET_ID, value); - } - - /** - * - * @see DownloadStatus - */ - public DownloadStatus getStatus() { - return this.status; - } - - /** - * - * @see DownloadStatus - */ - public DownloadInfo setStatus(DownloadStatus status) { - this.status = status; - return this; - } - - public void unsetStatus() { - this.status = null; - } - - /** Returns true if field status is set (has been assigned a value) and false otherwise */ - public boolean isSetStatus() { - return this.status != null; - } - - public void setStatusIsSet(boolean value) { - if (!value) { - this.status = null; - } - } - - public String getStatusmsg() { - return this.statusmsg; - } - - public DownloadInfo setStatusmsg(String statusmsg) { - this.statusmsg = statusmsg; - return this; - } - - public void unsetStatusmsg() { - this.statusmsg = null; - } - - /** Returns true if field statusmsg is set (has been assigned a value) and false otherwise */ - public boolean isSetStatusmsg() { - return this.statusmsg != null; - } - - public void setStatusmsgIsSet(boolean value) { - if (!value) { - this.statusmsg = null; - } - } - - public String getFormat_wait() { - return this.format_wait; - } - - public DownloadInfo setFormat_wait(String format_wait) { - this.format_wait = format_wait; - return this; - } - - public void unsetFormat_wait() { - this.format_wait = null; - } - - /** Returns true if field format_wait is set (has been assigned a value) and false otherwise */ - public boolean isSetFormat_wait() { - return this.format_wait != null; - } - - public void setFormat_waitIsSet(boolean value) { - if (!value) { - this.format_wait = null; - } - } - - public long getWait_until() { - return this.wait_until; - } - - public DownloadInfo setWait_until(long wait_until) { - this.wait_until = wait_until; - setWait_untilIsSet(true); - return this; - } - - public void unsetWait_until() { - __isset_bit_vector.clear(__WAIT_UNTIL_ISSET_ID); - } - - /** Returns true if field wait_until is set (has been assigned a value) and false otherwise */ - public boolean isSetWait_until() { - return __isset_bit_vector.get(__WAIT_UNTIL_ISSET_ID); - } - - public void setWait_untilIsSet(boolean value) { - __isset_bit_vector.set(__WAIT_UNTIL_ISSET_ID, value); - } - - public int getPackageID() { - return this.packageID; - } - - public DownloadInfo setPackageID(int packageID) { - this.packageID = packageID; - setPackageIDIsSet(true); - return this; - } - - public void unsetPackageID() { - __isset_bit_vector.clear(__PACKAGEID_ISSET_ID); - } - - /** Returns true if field packageID is set (has been assigned a value) and false otherwise */ - public boolean isSetPackageID() { - return __isset_bit_vector.get(__PACKAGEID_ISSET_ID); - } - - public void setPackageIDIsSet(boolean value) { - __isset_bit_vector.set(__PACKAGEID_ISSET_ID, value); - } - - public String getPackageName() { - return this.packageName; - } - - public DownloadInfo setPackageName(String packageName) { - this.packageName = packageName; - return this; - } - - public void unsetPackageName() { - this.packageName = null; - } - - /** Returns true if field packageName is set (has been assigned a value) and false otherwise */ - public boolean isSetPackageName() { - return this.packageName != null; - } - - public void setPackageNameIsSet(boolean value) { - if (!value) { - this.packageName = null; - } - } - - public String getPlugin() { - return this.plugin; - } - - public DownloadInfo setPlugin(String plugin) { - this.plugin = plugin; - return this; - } - - public void unsetPlugin() { - this.plugin = null; - } - - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } - - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); - } - break; - - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case SPEED: - if (value == null) { - unsetSpeed(); - } else { - setSpeed((Long)value); - } - break; - - case ETA: - if (value == null) { - unsetEta(); - } else { - setEta((Integer)value); - } - break; - - case FORMAT_ETA: - if (value == null) { - unsetFormat_eta(); - } else { - setFormat_eta((String)value); - } - break; - - case BLEFT: - if (value == null) { - unsetBleft(); - } else { - setBleft((Long)value); - } - break; - - case SIZE: - if (value == null) { - unsetSize(); - } else { - setSize((Long)value); - } - break; - - case FORMAT_SIZE: - if (value == null) { - unsetFormat_size(); - } else { - setFormat_size((String)value); - } - break; - - case PERCENT: - if (value == null) { - unsetPercent(); - } else { - setPercent((Byte)value); - } - break; - - case STATUS: - if (value == null) { - unsetStatus(); - } else { - setStatus((DownloadStatus)value); - } - break; - - case STATUSMSG: - if (value == null) { - unsetStatusmsg(); - } else { - setStatusmsg((String)value); - } - break; - - case FORMAT_WAIT: - if (value == null) { - unsetFormat_wait(); - } else { - setFormat_wait((String)value); - } - break; - - case WAIT_UNTIL: - if (value == null) { - unsetWait_until(); - } else { - setWait_until((Long)value); - } - break; - - case PACKAGE_ID: - if (value == null) { - unsetPackageID(); - } else { - setPackageID((Integer)value); - } - break; - - case PACKAGE_NAME: - if (value == null) { - unsetPackageName(); - } else { - setPackageName((String)value); - } - break; - - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); - - case NAME: - return getName(); - - case SPEED: - return Long.valueOf(getSpeed()); - - case ETA: - return Integer.valueOf(getEta()); - - case FORMAT_ETA: - return getFormat_eta(); - - case BLEFT: - return Long.valueOf(getBleft()); - - case SIZE: - return Long.valueOf(getSize()); - - case FORMAT_SIZE: - return getFormat_size(); - - case PERCENT: - return Byte.valueOf(getPercent()); - - case STATUS: - return getStatus(); - - case STATUSMSG: - return getStatusmsg(); - - case FORMAT_WAIT: - return getFormat_wait(); - - case WAIT_UNTIL: - return Long.valueOf(getWait_until()); - - case PACKAGE_ID: - return Integer.valueOf(getPackageID()); - - case PACKAGE_NAME: - return getPackageName(); - - case PLUGIN: - return getPlugin(); - - } - 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 FID: - return isSetFid(); - case NAME: - return isSetName(); - case SPEED: - return isSetSpeed(); - case ETA: - return isSetEta(); - case FORMAT_ETA: - return isSetFormat_eta(); - case BLEFT: - return isSetBleft(); - case SIZE: - return isSetSize(); - case FORMAT_SIZE: - return isSetFormat_size(); - case PERCENT: - return isSetPercent(); - case STATUS: - return isSetStatus(); - case STATUSMSG: - return isSetStatusmsg(); - case FORMAT_WAIT: - return isSetFormat_wait(); - case WAIT_UNTIL: - return isSetWait_until(); - case PACKAGE_ID: - return isSetPackageID(); - case PACKAGE_NAME: - return isSetPackageName(); - case PLUGIN: - return isSetPlugin(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof DownloadInfo) - return this.equals((DownloadInfo)that); - return false; - } - - public boolean equals(DownloadInfo that) { - if (that == null) - return false; - - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; + public DownloadInfo setStatus(DownloadStatus status) { + this.status = status; + return this; } - 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; + public void unsetStatus() { + this.status = null; } - boolean this_present_speed = true; - boolean that_present_speed = true; - if (this_present_speed || that_present_speed) { - if (!(this_present_speed && that_present_speed)) - return false; - if (this.speed != that.speed) - return false; + /** Returns true if field status is set (has been assigned a value) and false otherwise */ + public boolean isSetStatus() { + return this.status != null; } - boolean this_present_eta = true; - boolean that_present_eta = true; - if (this_present_eta || that_present_eta) { - if (!(this_present_eta && that_present_eta)) - return false; - if (this.eta != that.eta) - return false; + public void setStatusIsSet(boolean value) { + if (!value) { + this.status = null; + } } - boolean this_present_format_eta = true && this.isSetFormat_eta(); - boolean that_present_format_eta = true && that.isSetFormat_eta(); - if (this_present_format_eta || that_present_format_eta) { - if (!(this_present_format_eta && that_present_format_eta)) - return false; - if (!this.format_eta.equals(that.format_eta)) - return false; + public String getStatusmsg() { + return this.statusmsg; } - boolean this_present_bleft = true; - boolean that_present_bleft = true; - if (this_present_bleft || that_present_bleft) { - if (!(this_present_bleft && that_present_bleft)) - return false; - if (this.bleft != that.bleft) - return false; + public DownloadInfo setStatusmsg(String statusmsg) { + this.statusmsg = statusmsg; + return this; } - boolean this_present_size = true; - boolean that_present_size = true; - if (this_present_size || that_present_size) { - if (!(this_present_size && that_present_size)) - return false; - if (this.size != that.size) - return false; + public void unsetStatusmsg() { + this.statusmsg = null; } - boolean this_present_format_size = true && this.isSetFormat_size(); - boolean that_present_format_size = true && that.isSetFormat_size(); - if (this_present_format_size || that_present_format_size) { - if (!(this_present_format_size && that_present_format_size)) - return false; - if (!this.format_size.equals(that.format_size)) - return false; + /** Returns true if field statusmsg is set (has been assigned a value) and false otherwise */ + public boolean isSetStatusmsg() { + return this.statusmsg != null; } - boolean this_present_percent = true; - boolean that_present_percent = true; - if (this_present_percent || that_present_percent) { - if (!(this_present_percent && that_present_percent)) - return false; - if (this.percent != that.percent) - return false; + public void setStatusmsgIsSet(boolean value) { + if (!value) { + this.statusmsg = null; + } } - boolean this_present_status = true && this.isSetStatus(); - boolean that_present_status = true && that.isSetStatus(); - if (this_present_status || that_present_status) { - if (!(this_present_status && that_present_status)) - return false; - if (!this.status.equals(that.status)) - return false; + public String getFormat_wait() { + return this.format_wait; } - boolean this_present_statusmsg = true && this.isSetStatusmsg(); - boolean that_present_statusmsg = true && that.isSetStatusmsg(); - if (this_present_statusmsg || that_present_statusmsg) { - if (!(this_present_statusmsg && that_present_statusmsg)) - return false; - if (!this.statusmsg.equals(that.statusmsg)) - return false; + public DownloadInfo setFormat_wait(String format_wait) { + this.format_wait = format_wait; + return this; } - boolean this_present_format_wait = true && this.isSetFormat_wait(); - boolean that_present_format_wait = true && that.isSetFormat_wait(); - if (this_present_format_wait || that_present_format_wait) { - if (!(this_present_format_wait && that_present_format_wait)) - return false; - if (!this.format_wait.equals(that.format_wait)) - return false; + public void unsetFormat_wait() { + this.format_wait = null; } - boolean this_present_wait_until = true; - boolean that_present_wait_until = true; - if (this_present_wait_until || that_present_wait_until) { - if (!(this_present_wait_until && that_present_wait_until)) - return false; - if (this.wait_until != that.wait_until) - return false; + /** Returns true if field format_wait is set (has been assigned a value) and false otherwise */ + public boolean isSetFormat_wait() { + return this.format_wait != null; } - boolean this_present_packageID = true; - boolean that_present_packageID = true; - if (this_present_packageID || that_present_packageID) { - if (!(this_present_packageID && that_present_packageID)) - return false; - if (this.packageID != that.packageID) - return false; + public void setFormat_waitIsSet(boolean value) { + if (!value) { + this.format_wait = null; + } } - boolean this_present_packageName = true && this.isSetPackageName(); - boolean that_present_packageName = true && that.isSetPackageName(); - if (this_present_packageName || that_present_packageName) { - if (!(this_present_packageName && that_present_packageName)) - return false; - if (!this.packageName.equals(that.packageName)) - return false; + public long getWait_until() { + return this.wait_until; } - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) + public DownloadInfo setWait_until(long wait_until) { + this.wait_until = wait_until; + setWait_untilIsSet(true); + return this; + } + + public void unsetWait_until() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __WAIT_UNTIL_ISSET_ID); + } + + /** Returns true if field wait_until is set (has been assigned a value) and false otherwise */ + public boolean isSetWait_until() { + return EncodingUtils.testBit(__isset_bitfield, __WAIT_UNTIL_ISSET_ID); + } + + public void setWait_untilIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __WAIT_UNTIL_ISSET_ID, value); + } + + public int getPackageID() { + return this.packageID; + } + + public DownloadInfo setPackageID(int packageID) { + this.packageID = packageID; + setPackageIDIsSet(true); + return this; + } + + public void unsetPackageID() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PACKAGEID_ISSET_ID); + } + + /** Returns true if field packageID is set (has been assigned a value) and false otherwise */ + public boolean isSetPackageID() { + return EncodingUtils.testBit(__isset_bitfield, __PACKAGEID_ISSET_ID); + } + + public void setPackageIDIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PACKAGEID_ISSET_ID, value); + } + + public String getPackageName() { + return this.packageName; + } + + public DownloadInfo setPackageName(String packageName) { + this.packageName = packageName; + return this; + } + + public void unsetPackageName() { + this.packageName = null; + } + + /** Returns true if field packageName is set (has been assigned a value) and false otherwise */ + public boolean isSetPackageName() { + return this.packageName != null; + } + + public void setPackageNameIsSet(boolean value) { + if (!value) { + this.packageName = null; + } + } + + public String getPlugin() { + return this.plugin; + } + + public DownloadInfo setPlugin(String plugin) { + this.plugin = plugin; + return this; + } + + public void unsetPlugin() { + this.plugin = null; + } + + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } + + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case SPEED: + if (value == null) { + unsetSpeed(); + } else { + setSpeed((Long) value); + } + break; + + case ETA: + if (value == null) { + unsetEta(); + } else { + setEta((Integer) value); + } + break; + + case FORMAT_ETA: + if (value == null) { + unsetFormat_eta(); + } else { + setFormat_eta((String) value); + } + break; + + case BLEFT: + if (value == null) { + unsetBleft(); + } else { + setBleft((Long) value); + } + break; + + case SIZE: + if (value == null) { + unsetSize(); + } else { + setSize((Long) value); + } + break; + + case FORMAT_SIZE: + if (value == null) { + unsetFormat_size(); + } else { + setFormat_size((String) value); + } + break; + + case PERCENT: + if (value == null) { + unsetPercent(); + } else { + setPercent((Byte) value); + } + break; + + case STATUS: + if (value == null) { + unsetStatus(); + } else { + setStatus((DownloadStatus) value); + } + break; + + case STATUSMSG: + if (value == null) { + unsetStatusmsg(); + } else { + setStatusmsg((String) value); + } + break; + + case FORMAT_WAIT: + if (value == null) { + unsetFormat_wait(); + } else { + setFormat_wait((String) value); + } + break; + + case WAIT_UNTIL: + if (value == null) { + unsetWait_until(); + } else { + setWait_until((Long) value); + } + break; + + case PACKAGE_ID: + if (value == null) { + unsetPackageID(); + } else { + setPackageID((Integer) value); + } + break; + + case PACKAGE_NAME: + if (value == null) { + unsetPackageName(); + } else { + setPackageName((String) value); + } + break; + + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); + + case NAME: + return getName(); + + case SPEED: + return getSpeed(); + + case ETA: + return getEta(); + + case FORMAT_ETA: + return getFormat_eta(); + + case BLEFT: + return getBleft(); + + case SIZE: + return getSize(); + + case FORMAT_SIZE: + return getFormat_size(); + + case PERCENT: + return getPercent(); + + case STATUS: + return getStatus(); + + case STATUSMSG: + return getStatusmsg(); + + case FORMAT_WAIT: + return getFormat_wait(); + + case WAIT_UNTIL: + return getWait_until(); + + case PACKAGE_ID: + return getPackageID(); + + case PACKAGE_NAME: + return getPackageName(); + + case PLUGIN: + return getPlugin(); + + } + 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 FID: + return isSetFid(); + case NAME: + return isSetName(); + case SPEED: + return isSetSpeed(); + case ETA: + return isSetEta(); + case FORMAT_ETA: + return isSetFormat_eta(); + case BLEFT: + return isSetBleft(); + case SIZE: + return isSetSize(); + case FORMAT_SIZE: + return isSetFormat_size(); + case PERCENT: + return isSetPercent(); + case STATUS: + return isSetStatus(); + case STATUSMSG: + return isSetStatusmsg(); + case FORMAT_WAIT: + return isSetFormat_wait(); + case WAIT_UNTIL: + return isSetWait_until(); + case PACKAGE_ID: + return isSetPackageID(); + case PACKAGE_NAME: + return isSetPackageName(); + case PLUGIN: + return isSetPlugin(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof DownloadInfo) + return this.equals((DownloadInfo) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(DownloadInfo other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - DownloadInfo typedOther = (DownloadInfo)other; - - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSpeed()).compareTo(typedOther.isSetSpeed()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSpeed()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.speed, typedOther.speed); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetEta()).compareTo(typedOther.isSetEta()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEta()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eta, typedOther.eta); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFormat_eta()).compareTo(typedOther.isSetFormat_eta()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFormat_eta()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_eta, typedOther.format_eta); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetBleft()).compareTo(typedOther.isSetBleft()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetBleft()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bleft, typedOther.bleft); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSize()).compareTo(typedOther.isSetSize()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSize()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, typedOther.size); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFormat_size()).compareTo(typedOther.isSetFormat_size()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFormat_size()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_size, typedOther.format_size); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPercent()).compareTo(typedOther.isSetPercent()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPercent()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.percent, typedOther.percent); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetStatus()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetStatusmsg()).compareTo(typedOther.isSetStatusmsg()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetStatusmsg()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statusmsg, typedOther.statusmsg); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFormat_wait()).compareTo(typedOther.isSetFormat_wait()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFormat_wait()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_wait, typedOther.format_wait); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetWait_until()).compareTo(typedOther.isSetWait_until()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetWait_until()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.wait_until, typedOther.wait_until); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPackageID()).compareTo(typedOther.isSetPackageID()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPackageID()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageID, typedOther.packageID); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPackageName()).compareTo(typedOther.isSetPackageName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPackageName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageName, typedOther.packageName); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - 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("DownloadInfo("); - boolean first = true; - - sb.append("fid:"); - sb.append(this.fid); - first = false; - if (!first) sb.append(", "); - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("speed:"); - sb.append(this.speed); - first = false; - if (!first) sb.append(", "); - sb.append("eta:"); - sb.append(this.eta); - first = false; - if (!first) sb.append(", "); - sb.append("format_eta:"); - if (this.format_eta == null) { - sb.append("null"); - } else { - sb.append(this.format_eta); - } - first = false; - if (!first) sb.append(", "); - sb.append("bleft:"); - sb.append(this.bleft); - first = false; - if (!first) sb.append(", "); - sb.append("size:"); - sb.append(this.size); - first = false; - if (!first) sb.append(", "); - sb.append("format_size:"); - if (this.format_size == null) { - sb.append("null"); - } else { - sb.append(this.format_size); - } - first = false; - if (!first) sb.append(", "); - sb.append("percent:"); - sb.append(this.percent); - first = false; - if (!first) sb.append(", "); - sb.append("status:"); - if (this.status == null) { - sb.append("null"); - } else { - sb.append(this.status); - } - first = false; - if (!first) sb.append(", "); - sb.append("statusmsg:"); - if (this.statusmsg == null) { - sb.append("null"); - } else { - sb.append(this.statusmsg); - } - first = false; - if (!first) sb.append(", "); - sb.append("format_wait:"); - if (this.format_wait == null) { - sb.append("null"); - } else { - sb.append(this.format_wait); - } - first = false; - if (!first) sb.append(", "); - sb.append("wait_until:"); - sb.append(this.wait_until); - first = false; - if (!first) sb.append(", "); - sb.append("packageID:"); - sb.append(this.packageID); - first = false; - if (!first) sb.append(", "); - sb.append("packageName:"); - if (this.packageName == null) { - sb.append("null"); - } else { - sb.append(this.packageName); - } - first = false; - if (!first) sb.append(", "); - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class DownloadInfoStandardSchemeFactory implements SchemeFactory { - public DownloadInfoStandardScheme getScheme() { - return new DownloadInfoStandardScheme(); - } - } - - private static class DownloadInfoStandardScheme extends StandardScheme<DownloadInfo> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, DownloadInfo 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: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // 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 3: // SPEED - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.speed = iprot.readI64(); - struct.setSpeedIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 4: // ETA - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.eta = iprot.readI32(); - struct.setEtaIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 5: // FORMAT_ETA - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.format_eta = iprot.readString(); - struct.setFormat_etaIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 6: // BLEFT - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.bleft = iprot.readI64(); - struct.setBleftIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 7: // SIZE - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 8: // FORMAT_SIZE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.format_size = iprot.readString(); - struct.setFormat_sizeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 9: // PERCENT - if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) { - struct.percent = iprot.readByte(); - struct.setPercentIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 10: // STATUS - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 11: // STATUSMSG - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.statusmsg = iprot.readString(); - struct.setStatusmsgIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 12: // FORMAT_WAIT - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.format_wait = iprot.readString(); - struct.setFormat_waitIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 13: // WAIT_UNTIL - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.wait_until = iprot.readI64(); - struct.setWait_untilIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 14: // PACKAGE_ID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.packageID = iprot.readI32(); - struct.setPackageIDIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 15: // PACKAGE_NAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.packageName = iprot.readString(); - struct.setPackageNameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 16: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(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, DownloadInfo struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - if (struct.name != null) { - oprot.writeFieldBegin(NAME_FIELD_DESC); - oprot.writeString(struct.name); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(SPEED_FIELD_DESC); - oprot.writeI64(struct.speed); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(ETA_FIELD_DESC); - oprot.writeI32(struct.eta); - oprot.writeFieldEnd(); - if (struct.format_eta != null) { - oprot.writeFieldBegin(FORMAT_ETA_FIELD_DESC); - oprot.writeString(struct.format_eta); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(BLEFT_FIELD_DESC); - oprot.writeI64(struct.bleft); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(SIZE_FIELD_DESC); - oprot.writeI64(struct.size); - oprot.writeFieldEnd(); - if (struct.format_size != null) { - oprot.writeFieldBegin(FORMAT_SIZE_FIELD_DESC); - oprot.writeString(struct.format_size); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(PERCENT_FIELD_DESC); - oprot.writeByte(struct.percent); - oprot.writeFieldEnd(); - if (struct.status != null) { - oprot.writeFieldBegin(STATUS_FIELD_DESC); - oprot.writeI32(struct.status.getValue()); - oprot.writeFieldEnd(); - } - if (struct.statusmsg != null) { - oprot.writeFieldBegin(STATUSMSG_FIELD_DESC); - oprot.writeString(struct.statusmsg); - oprot.writeFieldEnd(); - } - if (struct.format_wait != null) { - oprot.writeFieldBegin(FORMAT_WAIT_FIELD_DESC); - oprot.writeString(struct.format_wait); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(WAIT_UNTIL_FIELD_DESC); - oprot.writeI64(struct.wait_until); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(PACKAGE_ID_FIELD_DESC); - oprot.writeI32(struct.packageID); - oprot.writeFieldEnd(); - if (struct.packageName != null) { - oprot.writeFieldBegin(PACKAGE_NAME_FIELD_DESC); - oprot.writeString(struct.packageName); - oprot.writeFieldEnd(); - } - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class DownloadInfoTupleSchemeFactory implements SchemeFactory { - public DownloadInfoTupleScheme getScheme() { - return new DownloadInfoTupleScheme(); - } - } - - private static class DownloadInfoTupleScheme extends TupleScheme<DownloadInfo> { + public boolean equals(DownloadInfo that) { + if (that == null) + return false; + + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + 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_speed = true; + boolean that_present_speed = true; + if (this_present_speed || that_present_speed) { + if (!(this_present_speed && that_present_speed)) + return false; + if (this.speed != that.speed) + return false; + } + + boolean this_present_eta = true; + boolean that_present_eta = true; + if (this_present_eta || that_present_eta) { + if (!(this_present_eta && that_present_eta)) + return false; + if (this.eta != that.eta) + return false; + } + + boolean this_present_format_eta = true && this.isSetFormat_eta(); + boolean that_present_format_eta = true && that.isSetFormat_eta(); + if (this_present_format_eta || that_present_format_eta) { + if (!(this_present_format_eta && that_present_format_eta)) + return false; + if (!this.format_eta.equals(that.format_eta)) + return false; + } + + boolean this_present_bleft = true; + boolean that_present_bleft = true; + if (this_present_bleft || that_present_bleft) { + if (!(this_present_bleft && that_present_bleft)) + return false; + if (this.bleft != that.bleft) + return false; + } + + boolean this_present_size = true; + boolean that_present_size = true; + if (this_present_size || that_present_size) { + if (!(this_present_size && that_present_size)) + return false; + if (this.size != that.size) + return false; + } + + boolean this_present_format_size = true && this.isSetFormat_size(); + boolean that_present_format_size = true && that.isSetFormat_size(); + if (this_present_format_size || that_present_format_size) { + if (!(this_present_format_size && that_present_format_size)) + return false; + if (!this.format_size.equals(that.format_size)) + return false; + } + + boolean this_present_percent = true; + boolean that_present_percent = true; + if (this_present_percent || that_present_percent) { + if (!(this_present_percent && that_present_percent)) + return false; + if (this.percent != that.percent) + return false; + } + + boolean this_present_status = true && this.isSetStatus(); + boolean that_present_status = true && that.isSetStatus(); + if (this_present_status || that_present_status) { + if (!(this_present_status && that_present_status)) + return false; + if (!this.status.equals(that.status)) + return false; + } + + boolean this_present_statusmsg = true && this.isSetStatusmsg(); + boolean that_present_statusmsg = true && that.isSetStatusmsg(); + if (this_present_statusmsg || that_present_statusmsg) { + if (!(this_present_statusmsg && that_present_statusmsg)) + return false; + if (!this.statusmsg.equals(that.statusmsg)) + return false; + } + + boolean this_present_format_wait = true && this.isSetFormat_wait(); + boolean that_present_format_wait = true && that.isSetFormat_wait(); + if (this_present_format_wait || that_present_format_wait) { + if (!(this_present_format_wait && that_present_format_wait)) + return false; + if (!this.format_wait.equals(that.format_wait)) + return false; + } + + boolean this_present_wait_until = true; + boolean that_present_wait_until = true; + if (this_present_wait_until || that_present_wait_until) { + if (!(this_present_wait_until && that_present_wait_until)) + return false; + if (this.wait_until != that.wait_until) + return false; + } + + boolean this_present_packageID = true; + boolean that_present_packageID = true; + if (this_present_packageID || that_present_packageID) { + if (!(this_present_packageID && that_present_packageID)) + return false; + if (this.packageID != that.packageID) + return false; + } + + boolean this_present_packageName = true && this.isSetPackageName(); + boolean that_present_packageName = true && that.isSetPackageName(); + if (this_present_packageName || that_present_packageName) { + if (!(this_present_packageName && that_present_packageName)) + return false; + if (!this.packageName.equals(that.packageName)) + return false; + } + + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + return true; + } @Override - public void write(org.apache.thrift.protocol.TProtocol prot, DownloadInfo struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); - } - if (struct.isSetName()) { - optionals.set(1); - } - if (struct.isSetSpeed()) { - optionals.set(2); - } - if (struct.isSetEta()) { - optionals.set(3); - } - if (struct.isSetFormat_eta()) { - optionals.set(4); - } - if (struct.isSetBleft()) { - optionals.set(5); - } - if (struct.isSetSize()) { - optionals.set(6); - } - if (struct.isSetFormat_size()) { - optionals.set(7); - } - if (struct.isSetPercent()) { - optionals.set(8); - } - if (struct.isSetStatus()) { - optionals.set(9); - } - if (struct.isSetStatusmsg()) { - optionals.set(10); - } - if (struct.isSetFormat_wait()) { - optionals.set(11); - } - if (struct.isSetWait_until()) { - optionals.set(12); - } - if (struct.isSetPackageID()) { - optionals.set(13); - } - if (struct.isSetPackageName()) { - optionals.set(14); - } - if (struct.isSetPlugin()) { - optionals.set(15); - } - oprot.writeBitSet(optionals, 16); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); - } - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetSpeed()) { - oprot.writeI64(struct.speed); - } - if (struct.isSetEta()) { - oprot.writeI32(struct.eta); - } - if (struct.isSetFormat_eta()) { - oprot.writeString(struct.format_eta); - } - if (struct.isSetBleft()) { - oprot.writeI64(struct.bleft); - } - if (struct.isSetSize()) { - oprot.writeI64(struct.size); - } - if (struct.isSetFormat_size()) { - oprot.writeString(struct.format_size); - } - if (struct.isSetPercent()) { - oprot.writeByte(struct.percent); - } - if (struct.isSetStatus()) { - oprot.writeI32(struct.status.getValue()); - } - if (struct.isSetStatusmsg()) { - oprot.writeString(struct.statusmsg); - } - if (struct.isSetFormat_wait()) { - oprot.writeString(struct.format_wait); - } - if (struct.isSetWait_until()) { - oprot.writeI64(struct.wait_until); - } - if (struct.isSetPackageID()) { - oprot.writeI32(struct.packageID); - } - if (struct.isSetPackageName()) { - oprot.writeString(struct.packageName); - } - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_speed = true; + list.add(present_speed); + if (present_speed) + list.add(speed); + + boolean present_eta = true; + list.add(present_eta); + if (present_eta) + list.add(eta); + + boolean present_format_eta = true && (isSetFormat_eta()); + list.add(present_format_eta); + if (present_format_eta) + list.add(format_eta); + + boolean present_bleft = true; + list.add(present_bleft); + if (present_bleft) + list.add(bleft); + + boolean present_size = true; + list.add(present_size); + if (present_size) + list.add(size); + + boolean present_format_size = true && (isSetFormat_size()); + list.add(present_format_size); + if (present_format_size) + list.add(format_size); + + boolean present_percent = true; + list.add(present_percent); + if (present_percent) + list.add(percent); + + boolean present_status = true && (isSetStatus()); + list.add(present_status); + if (present_status) + list.add(status.getValue()); + + boolean present_statusmsg = true && (isSetStatusmsg()); + list.add(present_statusmsg); + if (present_statusmsg) + list.add(statusmsg); + + boolean present_format_wait = true && (isSetFormat_wait()); + list.add(present_format_wait); + if (present_format_wait) + list.add(format_wait); + + boolean present_wait_until = true; + list.add(present_wait_until); + if (present_wait_until) + list.add(wait_until); + + boolean present_packageID = true; + list.add(present_packageID); + if (present_packageID) + list.add(packageID); + + boolean present_packageName = true && (isSetPackageName()); + list.add(present_packageName); + if (present_packageName) + list.add(packageName); + + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); + + return list.hashCode(); } @Override - public void read(org.apache.thrift.protocol.TProtocol prot, DownloadInfo struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(16); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } - if (incoming.get(1)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(2)) { - struct.speed = iprot.readI64(); - struct.setSpeedIsSet(true); - } - if (incoming.get(3)) { - struct.eta = iprot.readI32(); - struct.setEtaIsSet(true); - } - if (incoming.get(4)) { - struct.format_eta = iprot.readString(); - struct.setFormat_etaIsSet(true); - } - if (incoming.get(5)) { - struct.bleft = iprot.readI64(); - struct.setBleftIsSet(true); - } - if (incoming.get(6)) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } - if (incoming.get(7)) { - struct.format_size = iprot.readString(); - struct.setFormat_sizeIsSet(true); - } - if (incoming.get(8)) { - struct.percent = iprot.readByte(); - struct.setPercentIsSet(true); - } - if (incoming.get(9)) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } - if (incoming.get(10)) { - struct.statusmsg = iprot.readString(); - struct.setStatusmsgIsSet(true); - } - if (incoming.get(11)) { - struct.format_wait = iprot.readString(); - struct.setFormat_waitIsSet(true); - } - if (incoming.get(12)) { - struct.wait_until = iprot.readI64(); - struct.setWait_untilIsSet(true); - } - if (incoming.get(13)) { - struct.packageID = iprot.readI32(); - struct.setPackageIDIsSet(true); - } - if (incoming.get(14)) { - struct.packageName = iprot.readString(); - struct.setPackageNameIsSet(true); - } - if (incoming.get(15)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - } - } + public int compareTo(DownloadInfo other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; + } + } + 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(isSetSpeed()).compareTo(other.isSetSpeed()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSpeed()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.speed, other.speed); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetEta()).compareTo(other.isSetEta()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEta()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eta, other.eta); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFormat_eta()).compareTo(other.isSetFormat_eta()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFormat_eta()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_eta, other.format_eta); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetBleft()).compareTo(other.isSetBleft()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetBleft()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.bleft, other.bleft); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSize()).compareTo(other.isSetSize()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSize()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, other.size); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFormat_size()).compareTo(other.isSetFormat_size()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFormat_size()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_size, other.format_size); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPercent()).compareTo(other.isSetPercent()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPercent()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.percent, other.percent); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetStatus()).compareTo(other.isSetStatus()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStatus()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, other.status); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetStatusmsg()).compareTo(other.isSetStatusmsg()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStatusmsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statusmsg, other.statusmsg); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFormat_wait()).compareTo(other.isSetFormat_wait()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFormat_wait()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_wait, other.format_wait); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetWait_until()).compareTo(other.isSetWait_until()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetWait_until()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.wait_until, other.wait_until); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPackageID()).compareTo(other.isSetPackageID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPackageID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageID, other.packageID); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPackageName()).compareTo(other.isSetPackageName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPackageName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageName, other.packageName); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + 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("DownloadInfo("); + boolean first = true; + + sb.append("fid:"); + sb.append(this.fid); + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("speed:"); + sb.append(this.speed); + first = false; + if (!first) sb.append(", "); + sb.append("eta:"); + sb.append(this.eta); + first = false; + if (!first) sb.append(", "); + sb.append("format_eta:"); + if (this.format_eta == null) { + sb.append("null"); + } else { + sb.append(this.format_eta); + } + first = false; + if (!first) sb.append(", "); + sb.append("bleft:"); + sb.append(this.bleft); + first = false; + if (!first) sb.append(", "); + sb.append("size:"); + sb.append(this.size); + first = false; + if (!first) sb.append(", "); + sb.append("format_size:"); + if (this.format_size == null) { + sb.append("null"); + } else { + sb.append(this.format_size); + } + first = false; + if (!first) sb.append(", "); + sb.append("percent:"); + sb.append(this.percent); + first = false; + if (!first) sb.append(", "); + sb.append("status:"); + if (this.status == null) { + sb.append("null"); + } else { + sb.append(this.status); + } + first = false; + if (!first) sb.append(", "); + sb.append("statusmsg:"); + if (this.statusmsg == null) { + sb.append("null"); + } else { + sb.append(this.statusmsg); + } + first = false; + if (!first) sb.append(", "); + sb.append("format_wait:"); + if (this.format_wait == null) { + sb.append("null"); + } else { + sb.append(this.format_wait); + } + first = false; + if (!first) sb.append(", "); + sb.append("wait_until:"); + sb.append(this.wait_until); + first = false; + if (!first) sb.append(", "); + sb.append("packageID:"); + sb.append(this.packageID); + first = false; + if (!first) sb.append(", "); + sb.append("packageName:"); + if (this.packageName == null) { + sb.append("null"); + } else { + sb.append(this.packageName); + } + first = false; + if (!first) sb.append(", "); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 DownloadInfoStandardSchemeFactory implements SchemeFactory { + public DownloadInfoStandardScheme getScheme() { + return new DownloadInfoStandardScheme(); + } + } + + private static class DownloadInfoStandardScheme extends StandardScheme<DownloadInfo> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, DownloadInfo 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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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 3: // SPEED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.speed = iprot.readI64(); + struct.setSpeedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // ETA + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.eta = iprot.readI32(); + struct.setEtaIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // FORMAT_ETA + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.format_eta = iprot.readString(); + struct.setFormat_etaIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // BLEFT + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.bleft = iprot.readI64(); + struct.setBleftIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // FORMAT_SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.format_size = iprot.readString(); + struct.setFormat_sizeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // PERCENT + if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) { + struct.percent = iprot.readByte(); + struct.setPercentIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // STATUS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // STATUSMSG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.statusmsg = iprot.readString(); + struct.setStatusmsgIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // FORMAT_WAIT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.format_wait = iprot.readString(); + struct.setFormat_waitIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 13: // WAIT_UNTIL + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.wait_until = iprot.readI64(); + struct.setWait_untilIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 14: // PACKAGE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.packageID = iprot.readI32(); + struct.setPackageIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 15: // PACKAGE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.packageName = iprot.readString(); + struct.setPackageNameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 16: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(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, DownloadInfo struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(SPEED_FIELD_DESC); + oprot.writeI64(struct.speed); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(ETA_FIELD_DESC); + oprot.writeI32(struct.eta); + oprot.writeFieldEnd(); + if (struct.format_eta != null) { + oprot.writeFieldBegin(FORMAT_ETA_FIELD_DESC); + oprot.writeString(struct.format_eta); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(BLEFT_FIELD_DESC); + oprot.writeI64(struct.bleft); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(SIZE_FIELD_DESC); + oprot.writeI64(struct.size); + oprot.writeFieldEnd(); + if (struct.format_size != null) { + oprot.writeFieldBegin(FORMAT_SIZE_FIELD_DESC); + oprot.writeString(struct.format_size); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PERCENT_FIELD_DESC); + oprot.writeByte(struct.percent); + oprot.writeFieldEnd(); + if (struct.status != null) { + oprot.writeFieldBegin(STATUS_FIELD_DESC); + oprot.writeI32(struct.status.getValue()); + oprot.writeFieldEnd(); + } + if (struct.statusmsg != null) { + oprot.writeFieldBegin(STATUSMSG_FIELD_DESC); + oprot.writeString(struct.statusmsg); + oprot.writeFieldEnd(); + } + if (struct.format_wait != null) { + oprot.writeFieldBegin(FORMAT_WAIT_FIELD_DESC); + oprot.writeString(struct.format_wait); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(WAIT_UNTIL_FIELD_DESC); + oprot.writeI64(struct.wait_until); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(PACKAGE_ID_FIELD_DESC); + oprot.writeI32(struct.packageID); + oprot.writeFieldEnd(); + if (struct.packageName != null) { + oprot.writeFieldBegin(PACKAGE_NAME_FIELD_DESC); + oprot.writeString(struct.packageName); + oprot.writeFieldEnd(); + } + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class DownloadInfoTupleSchemeFactory implements SchemeFactory { + public DownloadInfoTupleScheme getScheme() { + return new DownloadInfoTupleScheme(); + } + } + + private static class DownloadInfoTupleScheme extends TupleScheme<DownloadInfo> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, DownloadInfo struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + if (struct.isSetName()) { + optionals.set(1); + } + if (struct.isSetSpeed()) { + optionals.set(2); + } + if (struct.isSetEta()) { + optionals.set(3); + } + if (struct.isSetFormat_eta()) { + optionals.set(4); + } + if (struct.isSetBleft()) { + optionals.set(5); + } + if (struct.isSetSize()) { + optionals.set(6); + } + if (struct.isSetFormat_size()) { + optionals.set(7); + } + if (struct.isSetPercent()) { + optionals.set(8); + } + if (struct.isSetStatus()) { + optionals.set(9); + } + if (struct.isSetStatusmsg()) { + optionals.set(10); + } + if (struct.isSetFormat_wait()) { + optionals.set(11); + } + if (struct.isSetWait_until()) { + optionals.set(12); + } + if (struct.isSetPackageID()) { + optionals.set(13); + } + if (struct.isSetPackageName()) { + optionals.set(14); + } + if (struct.isSetPlugin()) { + optionals.set(15); + } + oprot.writeBitSet(optionals, 16); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetSpeed()) { + oprot.writeI64(struct.speed); + } + if (struct.isSetEta()) { + oprot.writeI32(struct.eta); + } + if (struct.isSetFormat_eta()) { + oprot.writeString(struct.format_eta); + } + if (struct.isSetBleft()) { + oprot.writeI64(struct.bleft); + } + if (struct.isSetSize()) { + oprot.writeI64(struct.size); + } + if (struct.isSetFormat_size()) { + oprot.writeString(struct.format_size); + } + if (struct.isSetPercent()) { + oprot.writeByte(struct.percent); + } + if (struct.isSetStatus()) { + oprot.writeI32(struct.status.getValue()); + } + if (struct.isSetStatusmsg()) { + oprot.writeString(struct.statusmsg); + } + if (struct.isSetFormat_wait()) { + oprot.writeString(struct.format_wait); + } + if (struct.isSetWait_until()) { + oprot.writeI64(struct.wait_until); + } + if (struct.isSetPackageID()) { + oprot.writeI32(struct.packageID); + } + if (struct.isSetPackageName()) { + oprot.writeString(struct.packageName); + } + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, DownloadInfo struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(16); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + if (incoming.get(1)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(2)) { + struct.speed = iprot.readI64(); + struct.setSpeedIsSet(true); + } + if (incoming.get(3)) { + struct.eta = iprot.readI32(); + struct.setEtaIsSet(true); + } + if (incoming.get(4)) { + struct.format_eta = iprot.readString(); + struct.setFormat_etaIsSet(true); + } + if (incoming.get(5)) { + struct.bleft = iprot.readI64(); + struct.setBleftIsSet(true); + } + if (incoming.get(6)) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(true); + } + if (incoming.get(7)) { + struct.format_size = iprot.readString(); + struct.setFormat_sizeIsSet(true); + } + if (incoming.get(8)) { + struct.percent = iprot.readByte(); + struct.setPercentIsSet(true); + } + if (incoming.get(9)) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } + if (incoming.get(10)) { + struct.statusmsg = iprot.readString(); + struct.setStatusmsgIsSet(true); + } + if (incoming.get(11)) { + struct.format_wait = iprot.readString(); + struct.setFormat_waitIsSet(true); + } + if (incoming.get(12)) { + struct.wait_until = iprot.readI64(); + struct.setWait_untilIsSet(true); + } + if (incoming.get(13)) { + struct.packageID = iprot.readI32(); + struct.setPackageIDIsSet(true); + } + if (incoming.get(14)) { + struct.packageName = iprot.readString(); + struct.setPackageNameIsSet(true); + } + if (incoming.get(15)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/DownloadStatus.java b/app/src/main/java/org/pyload/thrift/DownloadStatus.java index ebd6aea..ddb3823 100644 --- a/app/src/main/java/org/pyload/thrift/DownloadStatus.java +++ b/app/src/main/java/org/pyload/thrift/DownloadStatus.java @@ -1,84 +1,81 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; -import java.util.Map; -import java.util.HashMap; -import org.apache.thrift.TEnum; - public enum DownloadStatus implements org.apache.thrift.TEnum { - Finished(0), - Offline(1), - Online(2), - Queued(3), - Skipped(4), - Waiting(5), - TempOffline(6), - Starting(7), - Failed(8), - Aborted(9), - Decrypting(10), - Custom(11), - Downloading(12), - Processing(13), - Unknown(14); + Finished(0), + Offline(1), + Online(2), + Queued(3), + Skipped(4), + Waiting(5), + TempOffline(6), + Starting(7), + Failed(8), + Aborted(9), + Decrypting(10), + Custom(11), + Downloading(12), + Processing(13), + Unknown(14); - private final int value; + private final int value; - private DownloadStatus(int value) { - this.value = value; - } + private DownloadStatus(int value) { + this.value = value; + } - /** - * Get the integer value of this enum value, as defined in the Thrift IDL. - */ - public int getValue() { - return 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. - */ - public static DownloadStatus findByValue(int value) { - switch (value) { - case 0: - return Finished; - case 1: - return Offline; - case 2: - return Online; - case 3: - return Queued; - case 4: - return Skipped; - case 5: - return Waiting; - case 6: - return TempOffline; - case 7: - return Starting; - case 8: - return Failed; - case 9: - return Aborted; - case 10: - return Decrypting; - case 11: - return Custom; - case 12: - return Downloading; - case 13: - return Processing; - case 14: - return Unknown; - default: - return null; + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static DownloadStatus findByValue(int value) { + switch (value) { + case 0: + return Finished; + case 1: + return Offline; + case 2: + return Online; + case 3: + return Queued; + case 4: + return Skipped; + case 5: + return Waiting; + case 6: + return TempOffline; + case 7: + return Starting; + case 8: + return Failed; + case 9: + return Aborted; + case 10: + return Decrypting; + case 11: + return Custom; + case 12: + return Downloading; + case 13: + return Processing; + case 14: + return Unknown; + default: + return null; + } } - } } diff --git a/app/src/main/java/org/pyload/thrift/ElementType.java b/app/src/main/java/org/pyload/thrift/ElementType.java index 547ef91..4c423b1 100644 --- a/app/src/main/java/org/pyload/thrift/ElementType.java +++ b/app/src/main/java/org/pyload/thrift/ElementType.java @@ -1,45 +1,42 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; -import java.util.Map; -import java.util.HashMap; -import org.apache.thrift.TEnum; - public enum ElementType implements org.apache.thrift.TEnum { - Package(0), - File(1); + Package(0), + File(1); - private final int value; + private final int value; - private ElementType(int value) { - this.value = value; - } + private ElementType(int value) { + this.value = value; + } - /** - * Get the integer value of this enum value, as defined in the Thrift IDL. - */ - public int getValue() { - return 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. - */ - public static ElementType findByValue(int value) { - switch (value) { - case 0: - return Package; - case 1: - return File; - default: - return null; + /** + * Find a the enum type by its integer value, as defined in the Thrift IDL. + * @return null if the value is not found. + */ + public static ElementType findByValue(int value) { + switch (value) { + case 0: + return Package; + case 1: + return File; + default: + return null; + } } - } } diff --git a/app/src/main/java/org/pyload/thrift/Event.java b/app/src/main/java/org/pyload/thrift/Event.java deleted file mode 100644 index d836d90..0000000 --- a/app/src/main/java/org/pyload/thrift/Event.java +++ /dev/null @@ -1,611 +0,0 @@ -/** - * Autogenerated by Thrift - * - * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - */ -package org.pyload.thrift; - -import java.util.List; -import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; -import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; -import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.apache.thrift.*; -import org.apache.thrift.async.*; -import org.apache.thrift.meta_data.*; -import org.apache.thrift.transport.*; -import org.apache.thrift.protocol.*; - -public class Event implements TBase<Event, Event._Fields>, java.io.Serializable, Cloneable { - private static final TStruct STRUCT_DESC = new TStruct("Event"); - - private static final TField EVENT_FIELD_DESC = new TField("event", TType.STRING, (short)1); - private static final TField ID_FIELD_DESC = new TField("id", TType.I32, (short)2); - private static final TField TYPE_FIELD_DESC = new TField("type", TType.I32, (short)3); - private static final TField DESTINATION_FIELD_DESC = new TField("destination", TType.I32, (short)4); - - public String event; - public int id; - /** - * - * @see ElementType - */ - public ElementType type; - /** - * - * @see Destination - */ - public Destination destination; - - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements TFieldIdEnum { - EVENT((short)1, "event"), - ID((short)2, "id"), - /** - * - * @see ElementType - */ - TYPE((short)3, "type"), - /** - * - * @see Destination - */ - DESTINATION((short)4, "destination"); - - 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: // EVENT - return EVENT; - case 2: // ID - return ID; - case 3: // TYPE - return TYPE; - case 4: // DESTINATION - return DESTINATION; - default: - return null; - } - } - - /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. - */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __ID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - - public static final Map<_Fields, FieldMetaData> metaDataMap; - static { - Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.EVENT, new FieldMetaData("event", TFieldRequirementType.DEFAULT, - new FieldValueMetaData(TType.STRING))); - tmpMap.put(_Fields.ID, new FieldMetaData("id", TFieldRequirementType.OPTIONAL, - new FieldValueMetaData(TType.I32))); - tmpMap.put(_Fields.TYPE, new FieldMetaData("type", TFieldRequirementType.OPTIONAL, - new EnumMetaData(TType.ENUM, ElementType.class))); - tmpMap.put(_Fields.DESTINATION, new FieldMetaData("destination", TFieldRequirementType.OPTIONAL, - new EnumMetaData(TType.ENUM, Destination.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - FieldMetaData.addStructMetaDataMap(Event.class, metaDataMap); - } - - public Event() { - } - - public Event( - String event) - { - this(); - this.event = event; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public Event(Event other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetEvent()) { - this.event = other.event; - } - this.id = other.id; - if (other.isSetType()) { - this.type = other.type; - } - if (other.isSetDestination()) { - this.destination = other.destination; - } - } - - public Event deepCopy() { - return new Event(this); - } - - @Override - public void clear() { - this.event = null; - setIdIsSet(false); - this.id = 0; - this.type = null; - this.destination = null; - } - - public String getEvent() { - return this.event; - } - - public Event setEvent(String event) { - this.event = event; - return this; - } - - public void unsetEvent() { - this.event = null; - } - - /** Returns true if field event is set (has been asigned a value) and false otherwise */ - public boolean isSetEvent() { - return this.event != null; - } - - public void setEventIsSet(boolean value) { - if (!value) { - this.event = null; - } - } - - public int getId() { - return this.id; - } - - public Event setId(int id) { - this.id = id; - setIdIsSet(true); - return this; - } - - public void unsetId() { - __isset_bit_vector.clear(__ID_ISSET_ID); - } - - /** Returns true if field id is set (has been asigned a value) and false otherwise */ - public boolean isSetId() { - return __isset_bit_vector.get(__ID_ISSET_ID); - } - - public void setIdIsSet(boolean value) { - __isset_bit_vector.set(__ID_ISSET_ID, value); - } - - /** - * - * @see ElementType - */ - public ElementType getType() { - return this.type; - } - - /** - * - * @see ElementType - */ - public Event setType(ElementType type) { - this.type = type; - return this; - } - - public void unsetType() { - this.type = null; - } - - /** Returns true if field type is set (has been asigned a value) and false otherwise */ - public boolean isSetType() { - return this.type != null; - } - - public void setTypeIsSet(boolean value) { - if (!value) { - this.type = null; - } - } - - /** - * - * @see Destination - */ - public Destination getDestination() { - return this.destination; - } - - /** - * - * @see Destination - */ - public Event setDestination(Destination destination) { - this.destination = destination; - return this; - } - - public void unsetDestination() { - this.destination = null; - } - - /** Returns true if field destination is set (has been asigned a value) and false otherwise */ - public boolean isSetDestination() { - return this.destination != null; - } - - public void setDestinationIsSet(boolean value) { - if (!value) { - this.destination = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case EVENT: - if (value == null) { - unsetEvent(); - } else { - setEvent((String)value); - } - break; - - case ID: - if (value == null) { - unsetId(); - } else { - setId((Integer)value); - } - break; - - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((ElementType)value); - } - break; - - case DESTINATION: - if (value == null) { - unsetDestination(); - } else { - setDestination((Destination)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case EVENT: - return getEvent(); - - case ID: - return new Integer(getId()); - - case TYPE: - return getType(); - - case DESTINATION: - return getDestination(); - - } - throw new IllegalStateException(); - } - - /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case EVENT: - return isSetEvent(); - case ID: - return isSetId(); - case TYPE: - return isSetType(); - case DESTINATION: - return isSetDestination(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof Event) - return this.equals((Event)that); - return false; - } - - public boolean equals(Event that) { - if (that == null) - return false; - - boolean this_present_event = true && this.isSetEvent(); - boolean that_present_event = true && that.isSetEvent(); - if (this_present_event || that_present_event) { - if (!(this_present_event && that_present_event)) - return false; - if (!this.event.equals(that.event)) - return false; - } - - boolean this_present_id = true && this.isSetId(); - boolean that_present_id = true && that.isSetId(); - 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_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.equals(that.type)) - return false; - } - - boolean this_present_destination = true && this.isSetDestination(); - boolean that_present_destination = true && that.isSetDestination(); - if (this_present_destination || that_present_destination) { - if (!(this_present_destination && that_present_destination)) - return false; - if (!this.destination.equals(that.destination)) - return false; - } - - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(Event other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - Event typedOther = (Event)other; - - lastComparison = Boolean.valueOf(isSetEvent()).compareTo(typedOther.isSetEvent()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEvent()) { - lastComparison = TBaseHelper.compareTo(this.event, typedOther.event); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetId()).compareTo(typedOther.isSetId()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetId()) { - lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = TBaseHelper.compareTo(this.type, typedOther.type); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDestination()).compareTo(typedOther.isSetDestination()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDestination()) { - lastComparison = TBaseHelper.compareTo(this.destination, typedOther.destination); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } - - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } - - public void read(TProtocol iprot) throws TException { - TField field; - iprot.readStructBegin(); - while (true) - { - field = iprot.readFieldBegin(); - if (field.type == TType.STOP) { - break; - } - switch (field.id) { - case 1: // EVENT - if (field.type == TType.STRING) { - this.event = iprot.readString(); - } else { - TProtocolUtil.skip(iprot, field.type); - } - break; - case 2: // ID - if (field.type == TType.I32) { - this.id = iprot.readI32(); - setIdIsSet(true); - } else { - TProtocolUtil.skip(iprot, field.type); - } - break; - case 3: // TYPE - if (field.type == TType.I32) { - this.type = ElementType.findByValue(iprot.readI32()); - } else { - TProtocolUtil.skip(iprot, field.type); - } - break; - case 4: // DESTINATION - if (field.type == TType.I32) { - this.destination = Destination.findByValue(iprot.readI32()); - } else { - TProtocolUtil.skip(iprot, field.type); - } - break; - default: - TProtocolUtil.skip(iprot, field.type); - } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); - - // check for required fields of primitive type, which can't be checked in the validate method - validate(); - } - - public void write(TProtocol oprot) throws TException { - validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (this.event != null) { - oprot.writeFieldBegin(EVENT_FIELD_DESC); - oprot.writeString(this.event); - oprot.writeFieldEnd(); - } - if (isSetId()) { - oprot.writeFieldBegin(ID_FIELD_DESC); - oprot.writeI32(this.id); - oprot.writeFieldEnd(); - } - if (this.type != null) { - if (isSetType()) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeI32(this.type.getValue()); - oprot.writeFieldEnd(); - } - } - if (this.destination != null) { - if (isSetDestination()) { - oprot.writeFieldBegin(DESTINATION_FIELD_DESC); - oprot.writeI32(this.destination.getValue()); - oprot.writeFieldEnd(); - } - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder("Event("); - boolean first = true; - - sb.append("event:"); - if (this.event == null) { - sb.append("null"); - } else { - sb.append(this.event); - } - first = false; - if (isSetId()) { - if (!first) sb.append(", "); - sb.append("id:"); - sb.append(this.id); - first = false; - } - if (isSetType()) { - if (!first) sb.append(", "); - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - } - if (isSetDestination()) { - if (!first) sb.append(", "); - sb.append("destination:"); - if (this.destination == null) { - sb.append("null"); - } else { - sb.append(this.destination); - } - first = false; - } - sb.append(")"); - return sb.toString(); - } - - public void validate() throws TException { - // check for required fields - } - -} - diff --git a/app/src/main/java/org/pyload/thrift/EventInfo.java b/app/src/main/java/org/pyload/thrift/EventInfo.java index 7096566..dfd7834 100644 --- a/app/src/main/java/org/pyload/thrift/EventInfo.java +++ b/app/src/main/java/org/pyload/thrift/EventInfo.java @@ -1,719 +1,777 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class EventInfo implements org.apache.thrift.TBase<EventInfo, EventInfo._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("EventInfo"); - - private static final org.apache.thrift.protocol.TField EVENTNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("eventname", org.apache.thrift.protocol.TType.STRING, (short)1); - 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)2); - private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short)3); - private static final org.apache.thrift.protocol.TField DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short)4); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new EventInfoStandardSchemeFactory()); - schemes.put(TupleScheme.class, new EventInfoTupleSchemeFactory()); - } - - public String eventname; // required - public int id; // required - /** - * - * @see ElementType - */ - public ElementType type; // required - /** - * - * @see Destination - */ - public Destination destination; // 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 { - EVENTNAME((short)1, "eventname"), - ID((short)2, "id"), +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class EventInfo implements org.apache.thrift.TBase<EventInfo, EventInfo._Fields>, java.io.Serializable, Cloneable, Comparable<EventInfo>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("EventInfo"); + + private static final org.apache.thrift.protocol.TField EVENTNAME_FIELD_DESC = new org.apache.thrift.protocol.TField("eventname", org.apache.thrift.protocol.TType.STRING, (short) 1); + 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) 2); + private static final org.apache.thrift.protocol.TField TYPE_FIELD_DESC = new org.apache.thrift.protocol.TField("type", org.apache.thrift.protocol.TType.I32, (short) 3); + private static final org.apache.thrift.protocol.TField DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new EventInfoStandardSchemeFactory()); + schemes.put(TupleScheme.class, new EventInfoTupleSchemeFactory()); + } + + public String eventname; // required + public int id; // optional /** - * + * * @see ElementType */ - TYPE((short)3, "type"), + public ElementType type; // optional /** - * + * * @see Destination */ - DESTINATION((short)4, "destination"); + public Destination destination; // optional + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeString(eventname); + out.writeInt(id); + out.writeInt(type.getValue()); + out.writeInt(destination.getValue()); + } + + @Override + public int describeContents() { + return 0; + } + + public EventInfo(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.eventname = in.readString(); + this.id = in.readInt(); + this.type = ElementType.findByValue(in.readInt()); + this.destination = Destination.findByValue(in.readInt()); + } + + public static final android.os.Parcelable.Creator<EventInfo> CREATOR = new android.os.Parcelable.Creator<EventInfo>() { + @Override + public EventInfo[] newArray(int size) { + return new EventInfo[size]; + } + + @Override + public EventInfo createFromParcel(android.os.Parcel in) { + return new EventInfo(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + EVENTNAME((short) 1, "eventname"), + ID((short) 2, "id"), + /** + * + * @see ElementType + */ + TYPE((short) 3, "type"), + /** + * + * @see Destination + */ + DESTINATION((short) 4, "destination"); + + 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: // EVENTNAME + return EVENTNAME; + case 2: // ID + return ID; + case 3: // TYPE + return TYPE; + case 4: // DESTINATION + return DESTINATION; + 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; + } + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + // isset id assignments + private static final int __ID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.ID, _Fields.TYPE, _Fields.DESTINATION}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.EVENTNAME, new org.apache.thrift.meta_data.FieldMetaData("eventname", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, ElementType.class))); + tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(EventInfo.class, metaDataMap); + } + + public EventInfo() { + } + + public EventInfo( + String eventname) { + this(); + this.eventname = eventname; } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // EVENTNAME - return EVENTNAME; - case 2: // ID - return ID; - case 3: // TYPE - return TYPE; - case 4: // DESTINATION - return DESTINATION; - default: - return null; - } + public EventInfo(EventInfo other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetEventname()) { + this.eventname = other.eventname; + } + this.id = other.id; + if (other.isSetType()) { + this.type = other.type; + } + if (other.isSetDestination()) { + this.destination = other.destination; + } + } + + public EventInfo deepCopy() { + return new EventInfo(this); + } + + @Override + public void clear() { + this.eventname = null; + setIdIsSet(false); + this.id = 0; + this.type = null; + this.destination = null; + } + + public String getEventname() { + return this.eventname; + } + + public EventInfo setEventname(String eventname) { + this.eventname = eventname; + return this; + } + + public void unsetEventname() { + this.eventname = null; + } + + /** Returns true if field eventname is set (has been assigned a value) and false otherwise */ + public boolean isSetEventname() { + return this.eventname != null; + } + + public void setEventnameIsSet(boolean value) { + if (!value) { + this.eventname = null; + } + } + + public int getId() { + return this.id; + } + + public EventInfo setId(int id) { + this.id = id; + setIdIsSet(true); + return this; + } + + public void unsetId() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __ID_ISSET_ID); + } + + public void setIdIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ID_ISSET_ID, value); } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * + * @see ElementType */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public ElementType getType() { + return this.type; } /** - * Find the _Fields constant that matches name, or null if its not found. + * + * @see ElementType */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __ID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - private _Fields optionals[] = {_Fields.ID,_Fields.TYPE,_Fields.DESTINATION}; - 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.EVENTNAME, new org.apache.thrift.meta_data.FieldMetaData("eventname", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.ID, new org.apache.thrift.meta_data.FieldMetaData("id", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); - tmpMap.put(_Fields.TYPE, new org.apache.thrift.meta_data.FieldMetaData("type", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, ElementType.class))); - tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(EventInfo.class, metaDataMap); - } - - public EventInfo() { - } - - public EventInfo( - String eventname) - { - this(); - this.eventname = eventname; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public EventInfo(EventInfo other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetEventname()) { - this.eventname = other.eventname; - } - this.id = other.id; - if (other.isSetType()) { - this.type = other.type; - } - if (other.isSetDestination()) { - this.destination = other.destination; - } - } - - public EventInfo deepCopy() { - return new EventInfo(this); - } - - @Override - public void clear() { - this.eventname = null; - setIdIsSet(false); - this.id = 0; - this.type = null; - this.destination = null; - } - - public String getEventname() { - return this.eventname; - } - - public EventInfo setEventname(String eventname) { - this.eventname = eventname; - return this; - } - - public void unsetEventname() { - this.eventname = null; - } - - /** Returns true if field eventname is set (has been assigned a value) and false otherwise */ - public boolean isSetEventname() { - return this.eventname != null; - } - - public void setEventnameIsSet(boolean value) { - if (!value) { - this.eventname = null; - } - } - - public int getId() { - return this.id; - } - - public EventInfo setId(int id) { - this.id = id; - setIdIsSet(true); - return this; - } - - public void unsetId() { - __isset_bit_vector.clear(__ID_ISSET_ID); - } - - /** Returns true if field id is set (has been assigned a value) and false otherwise */ - public boolean isSetId() { - return __isset_bit_vector.get(__ID_ISSET_ID); - } - - public void setIdIsSet(boolean value) { - __isset_bit_vector.set(__ID_ISSET_ID, value); - } - - /** - * - * @see ElementType - */ - public ElementType getType() { - return this.type; - } - - /** - * - * @see ElementType - */ - public EventInfo setType(ElementType type) { - this.type = type; - return this; - } - - public void unsetType() { - this.type = null; - } - - /** Returns true if field type is set (has been assigned a value) and false otherwise */ - public boolean isSetType() { - return this.type != null; - } - - public void setTypeIsSet(boolean value) { - if (!value) { - this.type = null; - } - } - - /** - * - * @see Destination - */ - public Destination getDestination() { - return this.destination; - } - - /** - * - * @see Destination - */ - public EventInfo setDestination(Destination destination) { - this.destination = destination; - return this; - } - - public void unsetDestination() { - this.destination = null; - } - - /** Returns true if field destination is set (has been assigned a value) and false otherwise */ - public boolean isSetDestination() { - return this.destination != null; - } - - public void setDestinationIsSet(boolean value) { - if (!value) { - this.destination = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case EVENTNAME: - if (value == null) { - unsetEventname(); - } else { - setEventname((String)value); - } - break; - - case ID: - if (value == null) { - unsetId(); - } else { - setId((Integer)value); - } - break; - - case TYPE: - if (value == null) { - unsetType(); - } else { - setType((ElementType)value); - } - break; - - case DESTINATION: - if (value == null) { - unsetDestination(); - } else { - setDestination((Destination)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case EVENTNAME: - return getEventname(); - - case ID: - return Integer.valueOf(getId()); - - case TYPE: - return getType(); - - case DESTINATION: - return getDestination(); - - } - 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 EVENTNAME: - return isSetEventname(); - case ID: - return isSetId(); - case TYPE: - return isSetType(); - case DESTINATION: - return isSetDestination(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof EventInfo) - return this.equals((EventInfo)that); - return false; - } - - public boolean equals(EventInfo that) { - if (that == null) - return false; - - boolean this_present_eventname = true && this.isSetEventname(); - boolean that_present_eventname = true && that.isSetEventname(); - if (this_present_eventname || that_present_eventname) { - if (!(this_present_eventname && that_present_eventname)) - return false; - if (!this.eventname.equals(that.eventname)) - return false; + public EventInfo setType(ElementType type) { + this.type = type; + return this; } - boolean this_present_id = true && this.isSetId(); - boolean that_present_id = true && that.isSetId(); - if (this_present_id || that_present_id) { - if (!(this_present_id && that_present_id)) - return false; - if (this.id != that.id) - return false; + public void unsetType() { + this.type = null; } - 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.equals(that.type)) - return false; + /** Returns true if field type is set (has been assigned a value) and false otherwise */ + public boolean isSetType() { + return this.type != null; } - boolean this_present_destination = true && this.isSetDestination(); - boolean that_present_destination = true && that.isSetDestination(); - if (this_present_destination || that_present_destination) { - if (!(this_present_destination && that_present_destination)) - return false; - if (!this.destination.equals(that.destination)) + public void setTypeIsSet(boolean value) { + if (!value) { + this.type = null; + } + } + + /** + * + * @see Destination + */ + public Destination getDestination() { + return this.destination; + } + + /** + * + * @see Destination + */ + public EventInfo setDestination(Destination destination) { + this.destination = destination; + return this; + } + + public void unsetDestination() { + this.destination = null; + } + + /** Returns true if field destination is set (has been assigned a value) and false otherwise */ + public boolean isSetDestination() { + return this.destination != null; + } + + public void setDestinationIsSet(boolean value) { + if (!value) { + this.destination = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case EVENTNAME: + if (value == null) { + unsetEventname(); + } else { + setEventname((String) value); + } + break; + + case ID: + if (value == null) { + unsetId(); + } else { + setId((Integer) value); + } + break; + + case TYPE: + if (value == null) { + unsetType(); + } else { + setType((ElementType) value); + } + break; + + case DESTINATION: + if (value == null) { + unsetDestination(); + } else { + setDestination((Destination) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case EVENTNAME: + return getEventname(); + + case ID: + return getId(); + + case TYPE: + return getType(); + + case DESTINATION: + return getDestination(); + + } + 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 EVENTNAME: + return isSetEventname(); + case ID: + return isSetId(); + case TYPE: + return isSetType(); + case DESTINATION: + return isSetDestination(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof EventInfo) + return this.equals((EventInfo) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(EventInfo other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - EventInfo typedOther = (EventInfo)other; - - lastComparison = Boolean.valueOf(isSetEventname()).compareTo(typedOther.isSetEventname()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEventname()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventname, typedOther.eventname); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetId()).compareTo(typedOther.isSetId()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetId()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, typedOther.id); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetType()).compareTo(typedOther.isSetType()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetType()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, typedOther.type); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDestination()).compareTo(typedOther.isSetDestination()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDestination()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, typedOther.destination); - 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("EventInfo("); - boolean first = true; - - sb.append("eventname:"); - if (this.eventname == null) { - sb.append("null"); - } else { - sb.append(this.eventname); - } - first = false; - if (isSetId()) { - if (!first) sb.append(", "); - sb.append("id:"); - sb.append(this.id); - first = false; - } - if (isSetType()) { - if (!first) sb.append(", "); - sb.append("type:"); - if (this.type == null) { - sb.append("null"); - } else { - sb.append(this.type); - } - first = false; - } - if (isSetDestination()) { - if (!first) sb.append(", "); - sb.append("destination:"); - if (this.destination == null) { - sb.append("null"); - } else { - sb.append(this.destination); - } - first = false; - } - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class EventInfoStandardSchemeFactory implements SchemeFactory { - public EventInfoStandardScheme getScheme() { - return new EventInfoStandardScheme(); - } - } - - private static class EventInfoStandardScheme extends StandardScheme<EventInfo> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, EventInfo 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: // EVENTNAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.eventname = iprot.readString(); - struct.setEventnameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + public boolean equals(EventInfo that) { + if (that == null) + return false; + + boolean this_present_eventname = true && this.isSetEventname(); + boolean that_present_eventname = true && that.isSetEventname(); + if (this_present_eventname || that_present_eventname) { + if (!(this_present_eventname && that_present_eventname)) + return false; + if (!this.eventname.equals(that.eventname)) + return false; + } + + boolean this_present_id = true && this.isSetId(); + boolean that_present_id = true && that.isSetId(); + 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_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.equals(that.type)) + return false; + } + + boolean this_present_destination = true && this.isSetDestination(); + boolean that_present_destination = true && that.isSetDestination(); + if (this_present_destination || that_present_destination) { + if (!(this_present_destination && that_present_destination)) + return false; + if (!this.destination.equals(that.destination)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_eventname = true && (isSetEventname()); + list.add(present_eventname); + if (present_eventname) + list.add(eventname); + + boolean present_id = true && (isSetId()); + list.add(present_id); + if (present_id) + list.add(id); + + boolean present_type = true && (isSetType()); + list.add(present_type); + if (present_type) + list.add(type.getValue()); + + boolean present_destination = true && (isSetDestination()); + list.add(present_destination); + if (present_destination) + list.add(destination.getValue()); + + return list.hashCode(); + } + + @Override + public int compareTo(EventInfo other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetEventname()).compareTo(other.isSetEventname()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEventname()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.eventname, other.eventname); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // 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); + } + lastComparison = Boolean.valueOf(isSetId()).compareTo(other.isSetId()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetId()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.id, other.id); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // TYPE - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.type = ElementType.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetType()).compareTo(other.isSetType()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetType()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.type, other.type); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // DESTINATION - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetDestination()).compareTo(other.isSetDestination()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDestination()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, other.destination); + if (lastComparison != 0) { + return lastComparison; } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - // check for required fields of primitive type, which can't be checked in the validate method - struct.validate(); + 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, EventInfo struct) throws org.apache.thrift.TException { - struct.validate(); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - oprot.writeStructBegin(STRUCT_DESC); - if (struct.eventname != null) { - oprot.writeFieldBegin(EVENTNAME_FIELD_DESC); - oprot.writeString(struct.eventname); - oprot.writeFieldEnd(); - } - if (struct.isSetId()) { - oprot.writeFieldBegin(ID_FIELD_DESC); - oprot.writeI32(struct.id); - oprot.writeFieldEnd(); - } - if (struct.type != null) { - if (struct.isSetType()) { - oprot.writeFieldBegin(TYPE_FIELD_DESC); - oprot.writeI32(struct.type.getValue()); - oprot.writeFieldEnd(); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("EventInfo("); + boolean first = true; + + sb.append("eventname:"); + if (this.eventname == null) { + sb.append("null"); + } else { + sb.append(this.eventname); } - } - if (struct.destination != null) { - if (struct.isSetDestination()) { - oprot.writeFieldBegin(DESTINATION_FIELD_DESC); - oprot.writeI32(struct.destination.getValue()); - oprot.writeFieldEnd(); + first = false; + if (isSetId()) { + if (!first) sb.append(", "); + sb.append("id:"); + sb.append(this.id); + first = false; + } + if (isSetType()) { + if (!first) sb.append(", "); + sb.append("type:"); + if (this.type == null) { + sb.append("null"); + } else { + sb.append(this.type); + } + first = false; } - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); + if (isSetDestination()) { + if (!first) sb.append(", "); + sb.append("destination:"); + if (this.destination == null) { + sb.append("null"); + } else { + sb.append(this.destination); + } + 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 static class EventInfoTupleSchemeFactory implements SchemeFactory { - public EventInfoTupleScheme getScheme() { - return new EventInfoTupleScheme(); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - } - private static class EventInfoTupleScheme extends TupleScheme<EventInfo> { + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, EventInfo struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetEventname()) { - optionals.set(0); - } - if (struct.isSetId()) { - optionals.set(1); - } - if (struct.isSetType()) { - optionals.set(2); - } - if (struct.isSetDestination()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetEventname()) { - oprot.writeString(struct.eventname); - } - if (struct.isSetId()) { - oprot.writeI32(struct.id); - } - if (struct.isSetType()) { - oprot.writeI32(struct.type.getValue()); - } - if (struct.isSetDestination()) { - oprot.writeI32(struct.destination.getValue()); - } + private static class EventInfoStandardSchemeFactory implements SchemeFactory { + public EventInfoStandardScheme getScheme() { + return new EventInfoStandardScheme(); + } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, EventInfo struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.eventname = iprot.readString(); - struct.setEventnameIsSet(true); - } - if (incoming.get(1)) { - struct.id = iprot.readI32(); - struct.setIdIsSet(true); - } - if (incoming.get(2)) { - struct.type = ElementType.findByValue(iprot.readI32()); - struct.setTypeIsSet(true); - } - if (incoming.get(3)) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(true); - } - } - } + private static class EventInfoStandardScheme extends StandardScheme<EventInfo> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, EventInfo 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: // EVENTNAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.eventname = iprot.readString(); + struct.setEventnameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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 3: // TYPE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.type = org.pyload.thrift.ElementType.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // DESTINATION + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(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, EventInfo struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.eventname != null) { + oprot.writeFieldBegin(EVENTNAME_FIELD_DESC); + oprot.writeString(struct.eventname); + oprot.writeFieldEnd(); + } + if (struct.isSetId()) { + oprot.writeFieldBegin(ID_FIELD_DESC); + oprot.writeI32(struct.id); + oprot.writeFieldEnd(); + } + if (struct.type != null) { + if (struct.isSetType()) { + oprot.writeFieldBegin(TYPE_FIELD_DESC); + oprot.writeI32(struct.type.getValue()); + oprot.writeFieldEnd(); + } + } + if (struct.destination != null) { + if (struct.isSetDestination()) { + oprot.writeFieldBegin(DESTINATION_FIELD_DESC); + oprot.writeI32(struct.destination.getValue()); + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class EventInfoTupleSchemeFactory implements SchemeFactory { + public EventInfoTupleScheme getScheme() { + return new EventInfoTupleScheme(); + } + } + + private static class EventInfoTupleScheme extends TupleScheme<EventInfo> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, EventInfo struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetEventname()) { + optionals.set(0); + } + if (struct.isSetId()) { + optionals.set(1); + } + if (struct.isSetType()) { + optionals.set(2); + } + if (struct.isSetDestination()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetEventname()) { + oprot.writeString(struct.eventname); + } + if (struct.isSetId()) { + oprot.writeI32(struct.id); + } + if (struct.isSetType()) { + oprot.writeI32(struct.type.getValue()); + } + if (struct.isSetDestination()) { + oprot.writeI32(struct.destination.getValue()); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, EventInfo struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.eventname = iprot.readString(); + struct.setEventnameIsSet(true); + } + if (incoming.get(1)) { + struct.id = iprot.readI32(); + struct.setIdIsSet(true); + } + if (incoming.get(2)) { + struct.type = org.pyload.thrift.ElementType.findByValue(iprot.readI32()); + struct.setTypeIsSet(true); + } + if (incoming.get(3)) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/FileData.java b/app/src/main/java/org/pyload/thrift/FileData.java index 5e44b41..f985c9a 100644 --- a/app/src/main/java/org/pyload/thrift/FileData.java +++ b/app/src/main/java/org/pyload/thrift/FileData.java @@ -1,1379 +1,1486 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class FileData implements org.apache.thrift.TBase<FileData, FileData._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FileData"); - - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField URL_FIELD_DESC = new org.apache.thrift.protocol.TField("url", org.apache.thrift.protocol.TType.STRING, (short)2); - 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)3); - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)4); - private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short)5); - private static final org.apache.thrift.protocol.TField FORMAT_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("format_size", org.apache.thrift.protocol.TType.STRING, (short)6); - private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short)7); - private static final org.apache.thrift.protocol.TField STATUSMSG_FIELD_DESC = new org.apache.thrift.protocol.TField("statusmsg", org.apache.thrift.protocol.TType.STRING, (short)8); - private static final org.apache.thrift.protocol.TField PACKAGE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("packageID", org.apache.thrift.protocol.TType.I32, (short)9); - private static final org.apache.thrift.protocol.TField ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("error", org.apache.thrift.protocol.TType.STRING, (short)10); - private static final org.apache.thrift.protocol.TField ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("order", org.apache.thrift.protocol.TType.I16, (short)11); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new FileDataStandardSchemeFactory()); - schemes.put(TupleScheme.class, new FileDataTupleSchemeFactory()); - } - - public int fid; // required - public String url; // required - public String name; // required - public String plugin; // required - public long size; // required - public String format_size; // required - /** - * - * @see DownloadStatus - */ - public DownloadStatus status; // required - public String statusmsg; // required - public int packageID; // required - public String error; // required - public short order; // 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 { - FID((short)1, "fid"), - URL((short)2, "url"), - NAME((short)3, "name"), - PLUGIN((short)4, "plugin"), - SIZE((short)5, "size"), - FORMAT_SIZE((short)6, "format_size"), +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class FileData implements org.apache.thrift.TBase<FileData, FileData._Fields>, java.io.Serializable, Cloneable, Comparable<FileData>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FileData"); + + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField URL_FIELD_DESC = new org.apache.thrift.protocol.TField("url", org.apache.thrift.protocol.TType.STRING, (short) 2); + 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) 3); + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 4); + private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short) 5); + private static final org.apache.thrift.protocol.TField FORMAT_SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("format_size", org.apache.thrift.protocol.TType.STRING, (short) 6); + private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short) 7); + private static final org.apache.thrift.protocol.TField STATUSMSG_FIELD_DESC = new org.apache.thrift.protocol.TField("statusmsg", org.apache.thrift.protocol.TType.STRING, (short) 8); + private static final org.apache.thrift.protocol.TField PACKAGE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("packageID", org.apache.thrift.protocol.TType.I32, (short) 9); + private static final org.apache.thrift.protocol.TField ERROR_FIELD_DESC = new org.apache.thrift.protocol.TField("error", org.apache.thrift.protocol.TType.STRING, (short) 10); + private static final org.apache.thrift.protocol.TField ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("order", org.apache.thrift.protocol.TType.I16, (short) 11); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new FileDataStandardSchemeFactory()); + schemes.put(TupleScheme.class, new FileDataTupleSchemeFactory()); + } + + public int fid; // required + public String url; // required + public String name; // required + public String plugin; // required + public long size; // required + public String format_size; // required /** - * + * * @see DownloadStatus */ - STATUS((short)7, "status"), - STATUSMSG((short)8, "statusmsg"), - PACKAGE_ID((short)9, "packageID"), - ERROR((short)10, "error"), - ORDER((short)11, "order"); + public DownloadStatus status; // required + public String statusmsg; // required + public int packageID; // required + public String error; // required + public short order; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(fid); + out.writeString(url); + out.writeString(name); + out.writeString(plugin); + out.writeLong(size); + out.writeString(format_size); + out.writeInt(status.getValue()); + out.writeString(statusmsg); + out.writeInt(packageID); + out.writeString(error); + out.writeInt(new Short(order).intValue()); + } + + @Override + public int describeContents() { + return 0; + } + + public FileData(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.fid = in.readInt(); + this.url = in.readString(); + this.name = in.readString(); + this.plugin = in.readString(); + this.size = in.readLong(); + this.format_size = in.readString(); + this.status = DownloadStatus.findByValue(in.readInt()); + this.statusmsg = in.readString(); + this.packageID = in.readInt(); + this.error = in.readString(); + this.order = (short) in.readInt(); + } + + public static final android.os.Parcelable.Creator<FileData> CREATOR = new android.os.Parcelable.Creator<FileData>() { + @Override + public FileData[] newArray(int size) { + return new FileData[size]; + } + + @Override + public FileData createFromParcel(android.os.Parcel in) { + return new FileData(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"), + URL((short) 2, "url"), + NAME((short) 3, "name"), + PLUGIN((short) 4, "plugin"), + SIZE((short) 5, "size"), + FORMAT_SIZE((short) 6, "format_size"), + /** + * + * @see DownloadStatus + */ + STATUS((short) 7, "status"), + STATUSMSG((short) 8, "statusmsg"), + PACKAGE_ID((short) 9, "packageID"), + ERROR((short) 10, "error"), + ORDER((short) 11, "order"); + + 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: // FID + return FID; + case 2: // URL + return URL; + case 3: // NAME + return NAME; + case 4: // PLUGIN + return PLUGIN; + case 5: // SIZE + return SIZE; + case 6: // FORMAT_SIZE + return FORMAT_SIZE; + case 7: // STATUS + return STATUS; + case 8: // STATUSMSG + return STATUSMSG; + case 9: // PACKAGE_ID + return PACKAGE_ID; + case 10: // ERROR + return ERROR; + case 11: // ORDER + return ORDER; + 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; - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private static final int __SIZE_ISSET_ID = 1; + private static final int __PACKAGEID_ISSET_ID = 2; + private static final int __ORDER_ISSET_ID = 3; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + tmpMap.put(_Fields.URL, new org.apache.thrift.meta_data.FieldMetaData("url", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.FORMAT_SIZE, new org.apache.thrift.meta_data.FieldMetaData("format_size", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); + tmpMap.put(_Fields.STATUSMSG, new org.apache.thrift.meta_data.FieldMetaData("statusmsg", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PACKAGE_ID, new org.apache.thrift.meta_data.FieldMetaData("packageID", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.ERROR, new org.apache.thrift.meta_data.FieldMetaData("error", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ORDER, new org.apache.thrift.meta_data.FieldMetaData("order", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FileData.class, metaDataMap); + } + + public FileData() { + } + + public FileData( + int fid, + String url, + String name, + String plugin, + long size, + String format_size, + DownloadStatus status, + String statusmsg, + int packageID, + String error, + short order) { + this(); + this.fid = fid; + setFidIsSet(true); + this.url = url; + this.name = name; + this.plugin = plugin; + this.size = size; + setSizeIsSet(true); + this.format_size = format_size; + this.status = status; + this.statusmsg = statusmsg; + this.packageID = packageID; + setPackageIDIsSet(true); + this.error = error; + this.order = order; + setOrderIsSet(true); } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // FID - return FID; - case 2: // URL - return URL; - case 3: // NAME - return NAME; - case 4: // PLUGIN - return PLUGIN; - case 5: // SIZE - return SIZE; - case 6: // FORMAT_SIZE - return FORMAT_SIZE; - case 7: // STATUS - return STATUS; - case 8: // STATUSMSG - return STATUSMSG; - case 9: // PACKAGE_ID - return PACKAGE_ID; - case 10: // ERROR - return ERROR; - case 11: // ORDER - return ORDER; - default: - return null; - } + public FileData(FileData other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; + if (other.isSetUrl()) { + this.url = other.url; + } + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + this.size = other.size; + if (other.isSetFormat_size()) { + this.format_size = other.format_size; + } + if (other.isSetStatus()) { + this.status = other.status; + } + if (other.isSetStatusmsg()) { + this.statusmsg = other.statusmsg; + } + this.packageID = other.packageID; + if (other.isSetError()) { + this.error = other.error; + } + this.order = other.order; + } + + public FileData deepCopy() { + return new FileData(this); + } + + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + this.url = null; + this.name = null; + this.plugin = null; + setSizeIsSet(false); + this.size = 0; + this.format_size = null; + this.status = null; + this.statusmsg = null; + setPackageIDIsSet(false); + this.packageID = 0; + this.error = null; + setOrderIsSet(false); + this.order = 0; + } + + public int getFid() { + return this.fid; + } + + public FileData setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; + } + + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } + + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); + } + + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); + } + + public String getUrl() { + return this.url; + } + + public FileData setUrl(String url) { + this.url = url; + return this; + } + + public void unsetUrl() { + this.url = null; + } + + /** Returns true if field url is set (has been assigned a value) and false otherwise */ + public boolean isSetUrl() { + return this.url != null; + } + + public void setUrlIsSet(boolean value) { + if (!value) { + this.url = null; + } + } + + public String getName() { + return this.name; + } + + public FileData setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getPlugin() { + return this.plugin; + } + + public FileData setPlugin(String plugin) { + this.plugin = plugin; + return this; + } + + public void unsetPlugin() { + this.plugin = null; + } + + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } + + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } + + public long getSize() { + return this.size; + } + + public FileData setSize(long size) { + this.size = size; + setSizeIsSet(true); + return this; + } + + public void unsetSize() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + /** Returns true if field size is set (has been assigned a value) and false otherwise */ + public boolean isSetSize() { + return EncodingUtils.testBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + public void setSizeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SIZE_ISSET_ID, value); + } + + public String getFormat_size() { + return this.format_size; + } + + public FileData setFormat_size(String format_size) { + this.format_size = format_size; + return this; + } + + public void unsetFormat_size() { + this.format_size = null; + } + + /** Returns true if field format_size is set (has been assigned a value) and false otherwise */ + public boolean isSetFormat_size() { + return this.format_size != null; + } + + public void setFormat_sizeIsSet(boolean value) { + if (!value) { + this.format_size = null; + } } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * + * @see DownloadStatus */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public DownloadStatus getStatus() { + return this.status; } /** - * Find the _Fields constant that matches name, or null if its not found. + * + * @see DownloadStatus */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private static final int __SIZE_ISSET_ID = 1; - private static final int __PACKAGEID_ISSET_ID = 2; - private static final int __ORDER_ISSET_ID = 3; - private BitSet __isset_bit_vector = new BitSet(4); - 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.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - tmpMap.put(_Fields.URL, new org.apache.thrift.meta_data.FieldMetaData("url", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.FORMAT_SIZE, new org.apache.thrift.meta_data.FieldMetaData("format_size", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); - tmpMap.put(_Fields.STATUSMSG, new org.apache.thrift.meta_data.FieldMetaData("statusmsg", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PACKAGE_ID, new org.apache.thrift.meta_data.FieldMetaData("packageID", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.ERROR, new org.apache.thrift.meta_data.FieldMetaData("error", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.ORDER, new org.apache.thrift.meta_data.FieldMetaData("order", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FileData.class, metaDataMap); - } - - public FileData() { - } - - public FileData( - int fid, - String url, - String name, - String plugin, - long size, - String format_size, - DownloadStatus status, - String statusmsg, - int packageID, - String error, - short order) - { - this(); - this.fid = fid; - setFidIsSet(true); - this.url = url; - this.name = name; - this.plugin = plugin; - this.size = size; - setSizeIsSet(true); - this.format_size = format_size; - this.status = status; - this.statusmsg = statusmsg; - this.packageID = packageID; - setPackageIDIsSet(true); - this.error = error; - this.order = order; - setOrderIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public FileData(FileData other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - if (other.isSetUrl()) { - this.url = other.url; - } - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - this.size = other.size; - if (other.isSetFormat_size()) { - this.format_size = other.format_size; - } - if (other.isSetStatus()) { - this.status = other.status; - } - if (other.isSetStatusmsg()) { - this.statusmsg = other.statusmsg; - } - this.packageID = other.packageID; - if (other.isSetError()) { - this.error = other.error; - } - this.order = other.order; - } - - public FileData deepCopy() { - return new FileData(this); - } - - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - this.url = null; - this.name = null; - this.plugin = null; - setSizeIsSet(false); - this.size = 0; - this.format_size = null; - this.status = null; - this.statusmsg = null; - setPackageIDIsSet(false); - this.packageID = 0; - this.error = null; - setOrderIsSet(false); - this.order = 0; - } - - public int getFid() { - return this.fid; - } - - public FileData setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; - } - - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } - - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } - - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } - - public String getUrl() { - return this.url; - } - - public FileData setUrl(String url) { - this.url = url; - return this; - } - - public void unsetUrl() { - this.url = null; - } - - /** Returns true if field url is set (has been assigned a value) and false otherwise */ - public boolean isSetUrl() { - return this.url != null; - } - - public void setUrlIsSet(boolean value) { - if (!value) { - this.url = null; - } - } - - public String getName() { - return this.name; - } - - public FileData setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getPlugin() { - return this.plugin; - } - - public FileData setPlugin(String plugin) { - this.plugin = plugin; - return this; - } - - public void unsetPlugin() { - this.plugin = null; - } - - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } - - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } - - public long getSize() { - return this.size; - } - - public FileData setSize(long size) { - this.size = size; - setSizeIsSet(true); - return this; - } - - public void unsetSize() { - __isset_bit_vector.clear(__SIZE_ISSET_ID); - } - - /** Returns true if field size is set (has been assigned a value) and false otherwise */ - public boolean isSetSize() { - return __isset_bit_vector.get(__SIZE_ISSET_ID); - } - - public void setSizeIsSet(boolean value) { - __isset_bit_vector.set(__SIZE_ISSET_ID, value); - } - - public String getFormat_size() { - return this.format_size; - } - - public FileData setFormat_size(String format_size) { - this.format_size = format_size; - return this; - } - - public void unsetFormat_size() { - this.format_size = null; - } - - /** Returns true if field format_size is set (has been assigned a value) and false otherwise */ - public boolean isSetFormat_size() { - return this.format_size != null; - } - - public void setFormat_sizeIsSet(boolean value) { - if (!value) { - this.format_size = null; - } - } - - /** - * - * @see DownloadStatus - */ - public DownloadStatus getStatus() { - return this.status; - } - - /** - * - * @see DownloadStatus - */ - public FileData setStatus(DownloadStatus status) { - this.status = status; - return this; - } - - public void unsetStatus() { - this.status = null; - } - - /** Returns true if field status is set (has been assigned a value) and false otherwise */ - public boolean isSetStatus() { - return this.status != null; - } - - public void setStatusIsSet(boolean value) { - if (!value) { - this.status = null; - } - } - - public String getStatusmsg() { - return this.statusmsg; - } - - public FileData setStatusmsg(String statusmsg) { - this.statusmsg = statusmsg; - return this; - } - - public void unsetStatusmsg() { - this.statusmsg = null; - } - - /** Returns true if field statusmsg is set (has been assigned a value) and false otherwise */ - public boolean isSetStatusmsg() { - return this.statusmsg != null; - } - - public void setStatusmsgIsSet(boolean value) { - if (!value) { - this.statusmsg = null; - } - } - - public int getPackageID() { - return this.packageID; - } - - public FileData setPackageID(int packageID) { - this.packageID = packageID; - setPackageIDIsSet(true); - return this; - } - - public void unsetPackageID() { - __isset_bit_vector.clear(__PACKAGEID_ISSET_ID); - } - - /** Returns true if field packageID is set (has been assigned a value) and false otherwise */ - public boolean isSetPackageID() { - return __isset_bit_vector.get(__PACKAGEID_ISSET_ID); - } - - public void setPackageIDIsSet(boolean value) { - __isset_bit_vector.set(__PACKAGEID_ISSET_ID, value); - } - - public String getError() { - return this.error; - } - - public FileData setError(String error) { - this.error = error; - return this; - } - - public void unsetError() { - this.error = null; - } - - /** Returns true if field error is set (has been assigned a value) and false otherwise */ - public boolean isSetError() { - return this.error != null; - } - - public void setErrorIsSet(boolean value) { - if (!value) { - this.error = null; - } - } - - public short getOrder() { - return this.order; - } - - public FileData setOrder(short order) { - this.order = order; - setOrderIsSet(true); - return this; - } - - public void unsetOrder() { - __isset_bit_vector.clear(__ORDER_ISSET_ID); - } - - /** Returns true if field order is set (has been assigned a value) and false otherwise */ - public boolean isSetOrder() { - return __isset_bit_vector.get(__ORDER_ISSET_ID); - } - - public void setOrderIsSet(boolean value) { - __isset_bit_vector.set(__ORDER_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); - } - break; - - case URL: - if (value == null) { - unsetUrl(); - } else { - setUrl((String)value); - } - break; - - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); - } - break; - - case SIZE: - if (value == null) { - unsetSize(); - } else { - setSize((Long)value); - } - break; - - case FORMAT_SIZE: - if (value == null) { - unsetFormat_size(); - } else { - setFormat_size((String)value); - } - break; - - case STATUS: - if (value == null) { - unsetStatus(); - } else { - setStatus((DownloadStatus)value); - } - break; - - case STATUSMSG: - if (value == null) { - unsetStatusmsg(); - } else { - setStatusmsg((String)value); - } - break; - - case PACKAGE_ID: - if (value == null) { - unsetPackageID(); - } else { - setPackageID((Integer)value); - } - break; - - case ERROR: - if (value == null) { - unsetError(); - } else { - setError((String)value); - } - break; - - case ORDER: - if (value == null) { - unsetOrder(); - } else { - setOrder((Short)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); - - case URL: - return getUrl(); - - case NAME: - return getName(); - - case PLUGIN: - return getPlugin(); - - case SIZE: - return Long.valueOf(getSize()); - - case FORMAT_SIZE: - return getFormat_size(); - - case STATUS: - return getStatus(); - - case STATUSMSG: - return getStatusmsg(); - - case PACKAGE_ID: - return Integer.valueOf(getPackageID()); - - case ERROR: - return getError(); - - case ORDER: - return Short.valueOf(getOrder()); - - } - 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 FID: - return isSetFid(); - case URL: - return isSetUrl(); - case NAME: - return isSetName(); - case PLUGIN: - return isSetPlugin(); - case SIZE: - return isSetSize(); - case FORMAT_SIZE: - return isSetFormat_size(); - case STATUS: - return isSetStatus(); - case STATUSMSG: - return isSetStatusmsg(); - case PACKAGE_ID: - return isSetPackageID(); - case ERROR: - return isSetError(); - case ORDER: - return isSetOrder(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof FileData) - return this.equals((FileData)that); - return false; - } - - public boolean equals(FileData that) { - if (that == null) - return false; - - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; + public FileData setStatus(DownloadStatus status) { + this.status = status; + return this; } - boolean this_present_url = true && this.isSetUrl(); - boolean that_present_url = true && that.isSetUrl(); - if (this_present_url || that_present_url) { - if (!(this_present_url && that_present_url)) - return false; - if (!this.url.equals(that.url)) - return false; + public void unsetStatus() { + this.status = null; } - 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; + /** Returns true if field status is set (has been assigned a value) and false otherwise */ + public boolean isSetStatus() { + return this.status != null; } - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; + public void setStatusIsSet(boolean value) { + if (!value) { + this.status = null; + } } - boolean this_present_size = true; - boolean that_present_size = true; - if (this_present_size || that_present_size) { - if (!(this_present_size && that_present_size)) - return false; - if (this.size != that.size) - return false; + public String getStatusmsg() { + return this.statusmsg; } - boolean this_present_format_size = true && this.isSetFormat_size(); - boolean that_present_format_size = true && that.isSetFormat_size(); - if (this_present_format_size || that_present_format_size) { - if (!(this_present_format_size && that_present_format_size)) - return false; - if (!this.format_size.equals(that.format_size)) - return false; + public FileData setStatusmsg(String statusmsg) { + this.statusmsg = statusmsg; + return this; } - boolean this_present_status = true && this.isSetStatus(); - boolean that_present_status = true && that.isSetStatus(); - if (this_present_status || that_present_status) { - if (!(this_present_status && that_present_status)) - return false; - if (!this.status.equals(that.status)) - return false; + public void unsetStatusmsg() { + this.statusmsg = null; } - boolean this_present_statusmsg = true && this.isSetStatusmsg(); - boolean that_present_statusmsg = true && that.isSetStatusmsg(); - if (this_present_statusmsg || that_present_statusmsg) { - if (!(this_present_statusmsg && that_present_statusmsg)) - return false; - if (!this.statusmsg.equals(that.statusmsg)) - return false; + /** Returns true if field statusmsg is set (has been assigned a value) and false otherwise */ + public boolean isSetStatusmsg() { + return this.statusmsg != null; } - boolean this_present_packageID = true; - boolean that_present_packageID = true; - if (this_present_packageID || that_present_packageID) { - if (!(this_present_packageID && that_present_packageID)) - return false; - if (this.packageID != that.packageID) - return false; + public void setStatusmsgIsSet(boolean value) { + if (!value) { + this.statusmsg = null; + } } - boolean this_present_error = true && this.isSetError(); - boolean that_present_error = true && that.isSetError(); - if (this_present_error || that_present_error) { - if (!(this_present_error && that_present_error)) - return false; - if (!this.error.equals(that.error)) - return false; + public int getPackageID() { + return this.packageID; } - boolean this_present_order = true; - boolean that_present_order = true; - if (this_present_order || that_present_order) { - if (!(this_present_order && that_present_order)) - return false; - if (this.order != that.order) + public FileData setPackageID(int packageID) { + this.packageID = packageID; + setPackageIDIsSet(true); + return this; + } + + public void unsetPackageID() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PACKAGEID_ISSET_ID); + } + + /** Returns true if field packageID is set (has been assigned a value) and false otherwise */ + public boolean isSetPackageID() { + return EncodingUtils.testBit(__isset_bitfield, __PACKAGEID_ISSET_ID); + } + + public void setPackageIDIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PACKAGEID_ISSET_ID, value); + } + + public String getError() { + return this.error; + } + + public FileData setError(String error) { + this.error = error; + return this; + } + + public void unsetError() { + this.error = null; + } + + /** Returns true if field error is set (has been assigned a value) and false otherwise */ + public boolean isSetError() { + return this.error != null; + } + + public void setErrorIsSet(boolean value) { + if (!value) { + this.error = null; + } + } + + public short getOrder() { + return this.order; + } + + public FileData setOrder(short order) { + this.order = order; + setOrderIsSet(true); + return this; + } + + public void unsetOrder() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ORDER_ISSET_ID); + } + + /** Returns true if field order is set (has been assigned a value) and false otherwise */ + public boolean isSetOrder() { + return EncodingUtils.testBit(__isset_bitfield, __ORDER_ISSET_ID); + } + + public void setOrderIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ORDER_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; + + case URL: + if (value == null) { + unsetUrl(); + } else { + setUrl((String) value); + } + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + case SIZE: + if (value == null) { + unsetSize(); + } else { + setSize((Long) value); + } + break; + + case FORMAT_SIZE: + if (value == null) { + unsetFormat_size(); + } else { + setFormat_size((String) value); + } + break; + + case STATUS: + if (value == null) { + unsetStatus(); + } else { + setStatus((DownloadStatus) value); + } + break; + + case STATUSMSG: + if (value == null) { + unsetStatusmsg(); + } else { + setStatusmsg((String) value); + } + break; + + case PACKAGE_ID: + if (value == null) { + unsetPackageID(); + } else { + setPackageID((Integer) value); + } + break; + + case ERROR: + if (value == null) { + unsetError(); + } else { + setError((String) value); + } + break; + + case ORDER: + if (value == null) { + unsetOrder(); + } else { + setOrder((Short) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); + + case URL: + return getUrl(); + + case NAME: + return getName(); + + case PLUGIN: + return getPlugin(); + + case SIZE: + return getSize(); + + case FORMAT_SIZE: + return getFormat_size(); + + case STATUS: + return getStatus(); + + case STATUSMSG: + return getStatusmsg(); + + case PACKAGE_ID: + return getPackageID(); + + case ERROR: + return getError(); + + case ORDER: + return getOrder(); + + } + 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 FID: + return isSetFid(); + case URL: + return isSetUrl(); + case NAME: + return isSetName(); + case PLUGIN: + return isSetPlugin(); + case SIZE: + return isSetSize(); + case FORMAT_SIZE: + return isSetFormat_size(); + case STATUS: + return isSetStatus(); + case STATUSMSG: + return isSetStatusmsg(); + case PACKAGE_ID: + return isSetPackageID(); + case ERROR: + return isSetError(); + case ORDER: + return isSetOrder(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof FileData) + return this.equals((FileData) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(FileData other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - FileData typedOther = (FileData)other; - - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetUrl()).compareTo(typedOther.isSetUrl()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUrl()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.url, typedOther.url); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSize()).compareTo(typedOther.isSetSize()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSize()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, typedOther.size); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFormat_size()).compareTo(typedOther.isSetFormat_size()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFormat_size()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_size, typedOther.format_size); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetStatus()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetStatusmsg()).compareTo(typedOther.isSetStatusmsg()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetStatusmsg()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statusmsg, typedOther.statusmsg); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPackageID()).compareTo(typedOther.isSetPackageID()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPackageID()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageID, typedOther.packageID); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetError()).compareTo(typedOther.isSetError()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetError()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.error, typedOther.error); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOrder()).compareTo(typedOther.isSetOrder()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOrder()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.order, typedOther.order); - 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("FileData("); - boolean first = true; - - sb.append("fid:"); - sb.append(this.fid); - first = false; - if (!first) sb.append(", "); - sb.append("url:"); - if (this.url == null) { - sb.append("null"); - } else { - sb.append(this.url); - } - first = false; - if (!first) sb.append(", "); - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("size:"); - sb.append(this.size); - first = false; - if (!first) sb.append(", "); - sb.append("format_size:"); - if (this.format_size == null) { - sb.append("null"); - } else { - sb.append(this.format_size); - } - first = false; - if (!first) sb.append(", "); - sb.append("status:"); - if (this.status == null) { - sb.append("null"); - } else { - sb.append(this.status); - } - first = false; - if (!first) sb.append(", "); - sb.append("statusmsg:"); - if (this.statusmsg == null) { - sb.append("null"); - } else { - sb.append(this.statusmsg); - } - first = false; - if (!first) sb.append(", "); - sb.append("packageID:"); - sb.append(this.packageID); - first = false; - if (!first) sb.append(", "); - sb.append("error:"); - if (this.error == null) { - sb.append("null"); - } else { - sb.append(this.error); - } - first = false; - if (!first) sb.append(", "); - sb.append("order:"); - sb.append(this.order); - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class FileDataStandardSchemeFactory implements SchemeFactory { - public FileDataStandardScheme getScheme() { - return new FileDataStandardScheme(); - } - } - - private static class FileDataStandardScheme extends StandardScheme<FileData> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, FileData 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: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + public boolean equals(FileData that) { + if (that == null) + return false; + + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + return false; + } + + boolean this_present_url = true && this.isSetUrl(); + boolean that_present_url = true && that.isSetUrl(); + if (this_present_url || that_present_url) { + if (!(this_present_url && that_present_url)) + return false; + if (!this.url.equals(that.url)) + 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_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + boolean this_present_size = true; + boolean that_present_size = true; + if (this_present_size || that_present_size) { + if (!(this_present_size && that_present_size)) + return false; + if (this.size != that.size) + return false; + } + + boolean this_present_format_size = true && this.isSetFormat_size(); + boolean that_present_format_size = true && that.isSetFormat_size(); + if (this_present_format_size || that_present_format_size) { + if (!(this_present_format_size && that_present_format_size)) + return false; + if (!this.format_size.equals(that.format_size)) + return false; + } + + boolean this_present_status = true && this.isSetStatus(); + boolean that_present_status = true && that.isSetStatus(); + if (this_present_status || that_present_status) { + if (!(this_present_status && that_present_status)) + return false; + if (!this.status.equals(that.status)) + return false; + } + + boolean this_present_statusmsg = true && this.isSetStatusmsg(); + boolean that_present_statusmsg = true && that.isSetStatusmsg(); + if (this_present_statusmsg || that_present_statusmsg) { + if (!(this_present_statusmsg && that_present_statusmsg)) + return false; + if (!this.statusmsg.equals(that.statusmsg)) + return false; + } + + boolean this_present_packageID = true; + boolean that_present_packageID = true; + if (this_present_packageID || that_present_packageID) { + if (!(this_present_packageID && that_present_packageID)) + return false; + if (this.packageID != that.packageID) + return false; + } + + boolean this_present_error = true && this.isSetError(); + boolean that_present_error = true && that.isSetError(); + if (this_present_error || that_present_error) { + if (!(this_present_error && that_present_error)) + return false; + if (!this.error.equals(that.error)) + return false; + } + + boolean this_present_order = true; + boolean that_present_order = true; + if (this_present_order || that_present_order) { + if (!(this_present_order && that_present_order)) + return false; + if (this.order != that.order) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); + + boolean present_url = true && (isSetUrl()); + list.add(present_url); + if (present_url) + list.add(url); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); + + boolean present_size = true; + list.add(present_size); + if (present_size) + list.add(size); + + boolean present_format_size = true && (isSetFormat_size()); + list.add(present_format_size); + if (present_format_size) + list.add(format_size); + + boolean present_status = true && (isSetStatus()); + list.add(present_status); + if (present_status) + list.add(status.getValue()); + + boolean present_statusmsg = true && (isSetStatusmsg()); + list.add(present_statusmsg); + if (present_statusmsg) + list.add(statusmsg); + + boolean present_packageID = true; + list.add(present_packageID); + if (present_packageID) + list.add(packageID); + + boolean present_error = true && (isSetError()); + list.add(present_error); + if (present_error) + list.add(error); + + boolean present_order = true; + list.add(present_order); + if (present_order) + list.add(order); + + return list.hashCode(); + } + + @Override + public int compareTo(FileData other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // URL - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.url = iprot.readString(); - struct.setUrlIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetUrl()).compareTo(other.isSetUrl()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUrl()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.url, other.url); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // 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); + } + 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; } - break; - case 4: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; } - break; - case 5: // SIZE - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetSize()).compareTo(other.isSetSize()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSize()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, other.size); + if (lastComparison != 0) { + return lastComparison; } - break; - case 6: // FORMAT_SIZE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.format_size = iprot.readString(); - struct.setFormat_sizeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetFormat_size()).compareTo(other.isSetFormat_size()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFormat_size()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.format_size, other.format_size); + if (lastComparison != 0) { + return lastComparison; } - break; - case 7: // STATUS - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetStatus()).compareTo(other.isSetStatus()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStatus()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, other.status); + if (lastComparison != 0) { + return lastComparison; } - break; - case 8: // STATUSMSG - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.statusmsg = iprot.readString(); - struct.setStatusmsgIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetStatusmsg()).compareTo(other.isSetStatusmsg()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStatusmsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.statusmsg, other.statusmsg); + if (lastComparison != 0) { + return lastComparison; } - break; - case 9: // PACKAGE_ID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.packageID = iprot.readI32(); - struct.setPackageIDIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPackageID()).compareTo(other.isSetPackageID()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPackageID()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packageID, other.packageID); + if (lastComparison != 0) { + return lastComparison; } - break; - case 10: // ERROR - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.error = iprot.readString(); - struct.setErrorIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetError()).compareTo(other.isSetError()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetError()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.error, other.error); + if (lastComparison != 0) { + return lastComparison; } - break; - case 11: // ORDER - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.order = iprot.readI16(); - struct.setOrderIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetOrder()).compareTo(other.isSetOrder()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOrder()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.order, other.order); + if (lastComparison != 0) { + return lastComparison; } - 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, FileData struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - if (struct.url != null) { - oprot.writeFieldBegin(URL_FIELD_DESC); - oprot.writeString(struct.url); - oprot.writeFieldEnd(); - } - if (struct.name != null) { - oprot.writeFieldBegin(NAME_FIELD_DESC); - oprot.writeString(struct.name); - oprot.writeFieldEnd(); - } - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(SIZE_FIELD_DESC); - oprot.writeI64(struct.size); - oprot.writeFieldEnd(); - if (struct.format_size != null) { - oprot.writeFieldBegin(FORMAT_SIZE_FIELD_DESC); - oprot.writeString(struct.format_size); - oprot.writeFieldEnd(); - } - if (struct.status != null) { - oprot.writeFieldBegin(STATUS_FIELD_DESC); - oprot.writeI32(struct.status.getValue()); - oprot.writeFieldEnd(); - } - if (struct.statusmsg != null) { - oprot.writeFieldBegin(STATUSMSG_FIELD_DESC); - oprot.writeString(struct.statusmsg); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(PACKAGE_ID_FIELD_DESC); - oprot.writeI32(struct.packageID); - oprot.writeFieldEnd(); - if (struct.error != null) { - oprot.writeFieldBegin(ERROR_FIELD_DESC); - oprot.writeString(struct.error); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(ORDER_FIELD_DESC); - oprot.writeI16(struct.order); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class FileDataTupleSchemeFactory implements SchemeFactory { - public FileDataTupleScheme getScheme() { - return new FileDataTupleScheme(); - } - } - - private static class FileDataTupleScheme extends TupleScheme<FileData> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, FileData struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); - } - if (struct.isSetUrl()) { - optionals.set(1); - } - if (struct.isSetName()) { - optionals.set(2); - } - if (struct.isSetPlugin()) { - optionals.set(3); - } - if (struct.isSetSize()) { - optionals.set(4); - } - if (struct.isSetFormat_size()) { - optionals.set(5); - } - if (struct.isSetStatus()) { - optionals.set(6); - } - if (struct.isSetStatusmsg()) { - optionals.set(7); - } - if (struct.isSetPackageID()) { - optionals.set(8); - } - if (struct.isSetError()) { - optionals.set(9); - } - if (struct.isSetOrder()) { - optionals.set(10); - } - oprot.writeBitSet(optionals, 11); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); - } - if (struct.isSetUrl()) { - oprot.writeString(struct.url); - } - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetSize()) { - oprot.writeI64(struct.size); - } - if (struct.isSetFormat_size()) { - oprot.writeString(struct.format_size); - } - if (struct.isSetStatus()) { - oprot.writeI32(struct.status.getValue()); - } - if (struct.isSetStatusmsg()) { - oprot.writeString(struct.statusmsg); - } - if (struct.isSetPackageID()) { - oprot.writeI32(struct.packageID); - } - if (struct.isSetError()) { - oprot.writeString(struct.error); - } - if (struct.isSetOrder()) { - oprot.writeI16(struct.order); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, FileData struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(11); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } - if (incoming.get(1)) { - struct.url = iprot.readString(); - struct.setUrlIsSet(true); - } - if (incoming.get(2)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(3)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(4)) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } - if (incoming.get(5)) { - struct.format_size = iprot.readString(); - struct.setFormat_sizeIsSet(true); - } - if (incoming.get(6)) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } - if (incoming.get(7)) { - struct.statusmsg = iprot.readString(); - struct.setStatusmsgIsSet(true); - } - if (incoming.get(8)) { - struct.packageID = iprot.readI32(); - struct.setPackageIDIsSet(true); - } - if (incoming.get(9)) { - struct.error = iprot.readString(); - struct.setErrorIsSet(true); - } - if (incoming.get(10)) { - struct.order = iprot.readI16(); - struct.setOrderIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("FileData("); + boolean first = true; + + sb.append("fid:"); + sb.append(this.fid); + first = false; + if (!first) sb.append(", "); + sb.append("url:"); + if (this.url == null) { + sb.append("null"); + } else { + sb.append(this.url); + } + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("size:"); + sb.append(this.size); + first = false; + if (!first) sb.append(", "); + sb.append("format_size:"); + if (this.format_size == null) { + sb.append("null"); + } else { + sb.append(this.format_size); + } + first = false; + if (!first) sb.append(", "); + sb.append("status:"); + if (this.status == null) { + sb.append("null"); + } else { + sb.append(this.status); + } + first = false; + if (!first) sb.append(", "); + sb.append("statusmsg:"); + if (this.statusmsg == null) { + sb.append("null"); + } else { + sb.append(this.statusmsg); + } + first = false; + if (!first) sb.append(", "); + sb.append("packageID:"); + sb.append(this.packageID); + first = false; + if (!first) sb.append(", "); + sb.append("error:"); + if (this.error == null) { + sb.append("null"); + } else { + sb.append(this.error); + } + first = false; + if (!first) sb.append(", "); + sb.append("order:"); + sb.append(this.order); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 FileDataStandardSchemeFactory implements SchemeFactory { + public FileDataStandardScheme getScheme() { + return new FileDataStandardScheme(); + } + } + + private static class FileDataStandardScheme extends StandardScheme<FileData> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, FileData 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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // URL + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.url = iprot.readString(); + struct.setUrlIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // 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 4: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // FORMAT_SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.format_size = iprot.readString(); + struct.setFormat_sizeIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // STATUS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // STATUSMSG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.statusmsg = iprot.readString(); + struct.setStatusmsgIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // PACKAGE_ID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.packageID = iprot.readI32(); + struct.setPackageIDIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // ERROR + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.error = iprot.readString(); + struct.setErrorIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // ORDER + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.order = iprot.readI16(); + struct.setOrderIsSet(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, FileData struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + if (struct.url != null) { + oprot.writeFieldBegin(URL_FIELD_DESC); + oprot.writeString(struct.url); + oprot.writeFieldEnd(); + } + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(SIZE_FIELD_DESC); + oprot.writeI64(struct.size); + oprot.writeFieldEnd(); + if (struct.format_size != null) { + oprot.writeFieldBegin(FORMAT_SIZE_FIELD_DESC); + oprot.writeString(struct.format_size); + oprot.writeFieldEnd(); + } + if (struct.status != null) { + oprot.writeFieldBegin(STATUS_FIELD_DESC); + oprot.writeI32(struct.status.getValue()); + oprot.writeFieldEnd(); + } + if (struct.statusmsg != null) { + oprot.writeFieldBegin(STATUSMSG_FIELD_DESC); + oprot.writeString(struct.statusmsg); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PACKAGE_ID_FIELD_DESC); + oprot.writeI32(struct.packageID); + oprot.writeFieldEnd(); + if (struct.error != null) { + oprot.writeFieldBegin(ERROR_FIELD_DESC); + oprot.writeString(struct.error); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(ORDER_FIELD_DESC); + oprot.writeI16(struct.order); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class FileDataTupleSchemeFactory implements SchemeFactory { + public FileDataTupleScheme getScheme() { + return new FileDataTupleScheme(); + } + } + + private static class FileDataTupleScheme extends TupleScheme<FileData> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, FileData struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + if (struct.isSetUrl()) { + optionals.set(1); + } + if (struct.isSetName()) { + optionals.set(2); + } + if (struct.isSetPlugin()) { + optionals.set(3); + } + if (struct.isSetSize()) { + optionals.set(4); + } + if (struct.isSetFormat_size()) { + optionals.set(5); + } + if (struct.isSetStatus()) { + optionals.set(6); + } + if (struct.isSetStatusmsg()) { + optionals.set(7); + } + if (struct.isSetPackageID()) { + optionals.set(8); + } + if (struct.isSetError()) { + optionals.set(9); + } + if (struct.isSetOrder()) { + optionals.set(10); + } + oprot.writeBitSet(optionals, 11); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + if (struct.isSetUrl()) { + oprot.writeString(struct.url); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetSize()) { + oprot.writeI64(struct.size); + } + if (struct.isSetFormat_size()) { + oprot.writeString(struct.format_size); + } + if (struct.isSetStatus()) { + oprot.writeI32(struct.status.getValue()); + } + if (struct.isSetStatusmsg()) { + oprot.writeString(struct.statusmsg); + } + if (struct.isSetPackageID()) { + oprot.writeI32(struct.packageID); + } + if (struct.isSetError()) { + oprot.writeString(struct.error); + } + if (struct.isSetOrder()) { + oprot.writeI16(struct.order); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, FileData struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(11); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + if (incoming.get(1)) { + struct.url = iprot.readString(); + struct.setUrlIsSet(true); + } + if (incoming.get(2)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(3)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(4)) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(true); + } + if (incoming.get(5)) { + struct.format_size = iprot.readString(); + struct.setFormat_sizeIsSet(true); + } + if (incoming.get(6)) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } + if (incoming.get(7)) { + struct.statusmsg = iprot.readString(); + struct.setStatusmsgIsSet(true); + } + if (incoming.get(8)) { + struct.packageID = iprot.readI32(); + struct.setPackageIDIsSet(true); + } + if (incoming.get(9)) { + struct.error = iprot.readString(); + struct.setErrorIsSet(true); + } + if (incoming.get(10)) { + struct.order = iprot.readI16(); + struct.setOrderIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/FileDoesNotExists.java b/app/src/main/java/org/pyload/thrift/FileDoesNotExists.java index f851675..2e98ed7 100644 --- a/app/src/main/java/org/pyload/thrift/FileDoesNotExists.java +++ b/app/src/main/java/org/pyload/thrift/FileDoesNotExists.java @@ -1,381 +1,419 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class FileDoesNotExists extends TException implements org.apache.thrift.TBase<FileDoesNotExists, FileDoesNotExists._Fields>, java.io.Serializable, Cloneable, Comparable<FileDoesNotExists>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FileDoesNotExists"); + + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new FileDoesNotExistsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new FileDoesNotExistsTupleSchemeFactory()); + } -public class FileDoesNotExists extends Exception implements org.apache.thrift.TBase<FileDoesNotExists, FileDoesNotExists._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("FileDoesNotExists"); + public int fid; // required - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new FileDoesNotExistsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new FileDoesNotExistsTupleSchemeFactory()); - } + out.writeInt(fid); + } - public int fid; // required + @Override + public int describeContents() { + return 0; + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - FID((short)1, "fid"); + public FileDoesNotExists(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + this.fid = in.readInt(); + } + + public static final android.os.Parcelable.Creator<FileDoesNotExists> CREATOR = new android.os.Parcelable.Creator<FileDoesNotExists>() { + @Override + public FileDoesNotExists[] newArray(int size) { + return new FileDoesNotExists[size]; + } + + @Override + public FileDoesNotExists createFromParcel(android.os.Parcel in) { + return new FileDoesNotExists(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"); + + 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: // FID + return FID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FileDoesNotExists.class, metaDataMap); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // FID - return FID; - default: - return null; - } + public FileDoesNotExists() { } - /** - * 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; + public FileDoesNotExists( + int fid) { + this(); + this.fid = fid; + setFidIsSet(true); } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - 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; + public FileDoesNotExists(FileDoesNotExists other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; } - } - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(FileDoesNotExists.class, metaDataMap); - } - - public FileDoesNotExists() { - } - - public FileDoesNotExists( - int fid) - { - this(); - this.fid = fid; - setFidIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public FileDoesNotExists(FileDoesNotExists other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - } - - public FileDoesNotExists deepCopy() { - return new FileDoesNotExists(this); - } - - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - } - - public int getFid() { - return this.fid; - } - - public FileDoesNotExists setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; - } - - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } - - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } - - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); - - } - 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 FID: - return isSetFid(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof FileDoesNotExists) - return this.equals((FileDoesNotExists)that); - return false; - } - - public boolean equals(FileDoesNotExists that) { - if (that == null) - return false; - - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; + public FileDoesNotExists deepCopy() { + return new FileDoesNotExists(this); } - return true; - } + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + } - @Override - public int hashCode() { - return 0; - } + public int getFid() { + return this.fid; + } - public int compareTo(FileDoesNotExists other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); + public FileDoesNotExists setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; } - int lastComparison = 0; - FileDoesNotExists typedOther = (FileDoesNotExists)other; + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } + + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); } - return 0; - } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; - 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); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("FileDoesNotExists("); - boolean first = true; + } + throw new IllegalStateException(); + } - sb.append("fid:"); - sb.append(this.fid); - first = false; - sb.append(")"); - return sb.toString(); - } + /** 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(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + switch (field) { + case FID: + return isSetFid(); + } + throw new IllegalStateException(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof FileDoesNotExists) + return this.equals((FileDoesNotExists) that); + return false; } - } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); + public boolean equals(FileDoesNotExists that) { + if (that == null) + return false; + + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + return false; + } + + return true; } - } - private static class FileDoesNotExistsStandardSchemeFactory implements SchemeFactory { - public FileDoesNotExistsStandardScheme getScheme() { - return new FileDoesNotExistsStandardScheme(); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); + + return list.hashCode(); } - } - private static class FileDoesNotExistsStandardScheme extends StandardScheme<FileDoesNotExists> { + @Override + public int compareTo(FileDoesNotExists other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void read(org.apache.thrift.protocol.TProtocol iprot, FileDoesNotExists 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; + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; } - switch (schemeField.id) { - case 1: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + 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); + } - // 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) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - public void write(org.apache.thrift.protocol.TProtocol oprot, FileDoesNotExists struct) throws org.apache.thrift.TException { - struct.validate(); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("FileDoesNotExists("); + boolean first = true; + + sb.append("fid:"); + sb.append(this.fid); + first = false; + sb.append(")"); + return sb.toString(); + } - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 FileDoesNotExistsTupleSchemeFactory implements SchemeFactory { - public FileDoesNotExistsTupleScheme getScheme() { - return new FileDoesNotExistsTupleScheme(); + private static class FileDoesNotExistsStandardSchemeFactory implements SchemeFactory { + public FileDoesNotExistsStandardScheme getScheme() { + return new FileDoesNotExistsStandardScheme(); + } } - } - private static class FileDoesNotExistsTupleScheme extends TupleScheme<FileDoesNotExists> { + private static class FileDoesNotExistsStandardScheme extends StandardScheme<FileDoesNotExists> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, FileDoesNotExists 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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(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, FileDoesNotExists struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, FileDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); - } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, FileDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } - } - } + private static class FileDoesNotExistsTupleSchemeFactory implements SchemeFactory { + public FileDoesNotExistsTupleScheme getScheme() { + return new FileDoesNotExistsTupleScheme(); + } + } + + private static class FileDoesNotExistsTupleScheme extends TupleScheme<FileDoesNotExists> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, FileDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, FileDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/Input.java b/app/src/main/java/org/pyload/thrift/Input.java new file mode 100644 index 0000000..34cd6be --- /dev/null +++ b/app/src/main/java/org/pyload/thrift/Input.java @@ -0,0 +1,66 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * <p> + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * + * @generated + */ +package org.pyload.thrift; + + +public enum Input implements org.apache.thrift.TEnum { + NONE(0), + TEXT(1), + TEXTBOX(2), + PASSWORD(3), + BOOL(4), + CLICK(5), + CHOICE(6), + MULTIPLE(7), + LIST(8), + TABLE(9); + + private final int value; + + private Input(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. + */ + public static Input findByValue(int value) { + switch (value) { + case 0: + return NONE; + case 1: + return TEXT; + case 2: + return TEXTBOX; + case 3: + return PASSWORD; + case 4: + return BOOL; + case 5: + return CLICK; + case 6: + return CHOICE; + case 7: + return MULTIPLE; + case 8: + return LIST; + case 9: + return TABLE; + default: + return null; + } + } +} diff --git a/app/src/main/java/org/pyload/thrift/InteractionTask.java b/app/src/main/java/org/pyload/thrift/InteractionTask.java new file mode 100644 index 0000000..eb6699d --- /dev/null +++ b/app/src/main/java/org/pyload/thrift/InteractionTask.java @@ -0,0 +1,1444 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * <p> + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * + * @generated + */ +package org.pyload.thrift; + +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; +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 java.util.ArrayList; +import java.util.BitSet; +import java.util.Collections; +import java.util.EnumMap; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class InteractionTask implements org.apache.thrift.TBase<InteractionTask, InteractionTask._Fields>, java.io.Serializable, Cloneable, Comparable<InteractionTask>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("InteractionTask"); + + private static final org.apache.thrift.protocol.TField IID_FIELD_DESC = new org.apache.thrift.protocol.TField("iid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField INPUT_FIELD_DESC = new org.apache.thrift.protocol.TField("input", org.apache.thrift.protocol.TType.I32, (short) 2); + private static final org.apache.thrift.protocol.TField STRUCTURE_FIELD_DESC = new org.apache.thrift.protocol.TField("structure", org.apache.thrift.protocol.TType.LIST, (short) 3); + private static final org.apache.thrift.protocol.TField PRESET_FIELD_DESC = new org.apache.thrift.protocol.TField("preset", org.apache.thrift.protocol.TType.LIST, (short) 4); + private static final org.apache.thrift.protocol.TField OUTPUT_FIELD_DESC = new org.apache.thrift.protocol.TField("output", org.apache.thrift.protocol.TType.I32, (short) 5); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.LIST, (short) 6); + private static final org.apache.thrift.protocol.TField TITLE_FIELD_DESC = new org.apache.thrift.protocol.TField("title", org.apache.thrift.protocol.TType.STRING, (short) 7); + private static final org.apache.thrift.protocol.TField DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short) 8); + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 9); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new InteractionTaskStandardSchemeFactory()); + schemes.put(TupleScheme.class, new InteractionTaskTupleSchemeFactory()); + } + + public int iid; // required + /** + * + * @see Input + */ + public Input input; // required + public List<String> structure; // required + public List<String> preset; // required + /** + * + * @see Output + */ + public Output output; // required + public List<String> data; // required + public String title; // required + public String description; // required + public String plugin; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(iid); + out.writeInt(input.getValue()); + out.writeList(structure); + out.writeList(preset); + out.writeInt(output.getValue()); + out.writeList(data); + out.writeString(title); + out.writeString(description); + out.writeString(plugin); + } + + @Override + public int describeContents() { + return 0; + } + + public InteractionTask(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.iid = in.readInt(); + this.input = Input.findByValue(in.readInt()); + this.structure = new ArrayList<String>(); + in.readList(this.structure, InteractionTask.class.getClassLoader()); + this.preset = new ArrayList<String>(); + in.readList(this.preset, InteractionTask.class.getClassLoader()); + this.output = Output.findByValue(in.readInt()); + this.data = new ArrayList<String>(); + in.readList(this.data, InteractionTask.class.getClassLoader()); + this.title = in.readString(); + this.description = in.readString(); + this.plugin = in.readString(); + } + + public static final android.os.Parcelable.Creator<InteractionTask> CREATOR = new android.os.Parcelable.Creator<InteractionTask>() { + @Override + public InteractionTask[] newArray(int size) { + return new InteractionTask[size]; + } + + @Override + public InteractionTask createFromParcel(android.os.Parcel in) { + return new InteractionTask(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + IID((short) 1, "iid"), + /** + * + * @see Input + */ + INPUT((short) 2, "input"), + STRUCTURE((short) 3, "structure"), + PRESET((short) 4, "preset"), + /** + * + * @see Output + */ + OUTPUT((short) 5, "output"), + DATA((short) 6, "data"), + TITLE((short) 7, "title"), + DESCRIPTION((short) 8, "description"), + PLUGIN((short) 9, "plugin"); + + 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: // IID + return IID; + case 2: // INPUT + return INPUT; + case 3: // STRUCTURE + return STRUCTURE; + case 4: // PRESET + return PRESET; + case 5: // OUTPUT + return OUTPUT; + case 6: // DATA + return DATA; + case 7: // TITLE + return TITLE; + case 8: // DESCRIPTION + return DESCRIPTION; + case 9: // PLUGIN + return PLUGIN; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __IID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.IID, new org.apache.thrift.meta_data.FieldMetaData("iid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "InteractionID"))); + tmpMap.put(_Fields.INPUT, new org.apache.thrift.meta_data.FieldMetaData("input", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Input.class))); + tmpMap.put(_Fields.STRUCTURE, new org.apache.thrift.meta_data.FieldMetaData("structure", 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.PRESET, new org.apache.thrift.meta_data.FieldMetaData("preset", 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.OUTPUT, new org.apache.thrift.meta_data.FieldMetaData("output", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Output.class))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", 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.TITLE, new org.apache.thrift.meta_data.FieldMetaData("title", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(InteractionTask.class, metaDataMap); + } + + public InteractionTask() { + } + + public InteractionTask( + int iid, + Input input, + List<String> structure, + List<String> preset, + Output output, + List<String> data, + String title, + String description, + String plugin) { + this(); + this.iid = iid; + setIidIsSet(true); + this.input = input; + this.structure = structure; + this.preset = preset; + this.output = output; + this.data = data; + this.title = title; + this.description = description; + this.plugin = plugin; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public InteractionTask(InteractionTask other) { + __isset_bitfield = other.__isset_bitfield; + this.iid = other.iid; + if (other.isSetInput()) { + this.input = other.input; + } + if (other.isSetStructure()) { + List<String> __this__structure = new ArrayList<String>(other.structure); + this.structure = __this__structure; + } + if (other.isSetPreset()) { + List<String> __this__preset = new ArrayList<String>(other.preset); + this.preset = __this__preset; + } + if (other.isSetOutput()) { + this.output = other.output; + } + if (other.isSetData()) { + List<String> __this__data = new ArrayList<String>(other.data); + this.data = __this__data; + } + if (other.isSetTitle()) { + this.title = other.title; + } + if (other.isSetDescription()) { + this.description = other.description; + } + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + } + + public InteractionTask deepCopy() { + return new InteractionTask(this); + } + + @Override + public void clear() { + setIidIsSet(false); + this.iid = 0; + this.input = null; + this.structure = null; + this.preset = null; + this.output = null; + this.data = null; + this.title = null; + this.description = null; + this.plugin = null; + } + + public int getIid() { + return this.iid; + } + + public InteractionTask setIid(int iid) { + this.iid = iid; + setIidIsSet(true); + return this; + } + + public void unsetIid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __IID_ISSET_ID); + } + + /** Returns true if field iid is set (has been assigned a value) and false otherwise */ + public boolean isSetIid() { + return EncodingUtils.testBit(__isset_bitfield, __IID_ISSET_ID); + } + + public void setIidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __IID_ISSET_ID, value); + } + + /** + * + * @see Input + */ + public Input getInput() { + return this.input; + } + + /** + * + * @see Input + */ + public InteractionTask setInput(Input input) { + this.input = input; + return this; + } + + public void unsetInput() { + this.input = null; + } + + /** Returns true if field input is set (has been assigned a value) and false otherwise */ + public boolean isSetInput() { + return this.input != null; + } + + public void setInputIsSet(boolean value) { + if (!value) { + this.input = null; + } + } + + public int getStructureSize() { + return (this.structure == null) ? 0 : this.structure.size(); + } + + public java.util.Iterator<String> getStructureIterator() { + return (this.structure == null) ? null : this.structure.iterator(); + } + + public void addToStructure(String elem) { + if (this.structure == null) { + this.structure = new ArrayList<String>(); + } + this.structure.add(elem); + } + + public List<String> getStructure() { + return this.structure; + } + + public InteractionTask setStructure(List<String> structure) { + this.structure = structure; + return this; + } + + public void unsetStructure() { + this.structure = null; + } + + /** Returns true if field structure is set (has been assigned a value) and false otherwise */ + public boolean isSetStructure() { + return this.structure != null; + } + + public void setStructureIsSet(boolean value) { + if (!value) { + this.structure = null; + } + } + + public int getPresetSize() { + return (this.preset == null) ? 0 : this.preset.size(); + } + + public java.util.Iterator<String> getPresetIterator() { + return (this.preset == null) ? null : this.preset.iterator(); + } + + public void addToPreset(String elem) { + if (this.preset == null) { + this.preset = new ArrayList<String>(); + } + this.preset.add(elem); + } + + public List<String> getPreset() { + return this.preset; + } + + public InteractionTask setPreset(List<String> preset) { + this.preset = preset; + return this; + } + + public void unsetPreset() { + this.preset = null; + } + + /** Returns true if field preset is set (has been assigned a value) and false otherwise */ + public boolean isSetPreset() { + return this.preset != null; + } + + public void setPresetIsSet(boolean value) { + if (!value) { + this.preset = null; + } + } + + /** + * + * @see Output + */ + public Output getOutput() { + return this.output; + } + + /** + * + * @see Output + */ + public InteractionTask setOutput(Output output) { + this.output = output; + return this; + } + + public void unsetOutput() { + this.output = null; + } + + /** Returns true if field output is set (has been assigned a value) and false otherwise */ + public boolean isSetOutput() { + return this.output != null; + } + + public void setOutputIsSet(boolean value) { + if (!value) { + this.output = null; + } + } + + public int getDataSize() { + return (this.data == null) ? 0 : this.data.size(); + } + + public java.util.Iterator<String> getDataIterator() { + return (this.data == null) ? null : this.data.iterator(); + } + + public void addToData(String elem) { + if (this.data == null) { + this.data = new ArrayList<String>(); + } + this.data.add(elem); + } + + public List<String> getData() { + return this.data; + } + + public InteractionTask setData(List<String> data) { + this.data = data; + return this; + } + + public void unsetData() { + this.data = null; + } + + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } + + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } + + public String getTitle() { + return this.title; + } + + public InteractionTask setTitle(String title) { + this.title = title; + return this; + } + + public void unsetTitle() { + this.title = null; + } + + /** Returns true if field title is set (has been assigned a value) and false otherwise */ + public boolean isSetTitle() { + return this.title != null; + } + + public void setTitleIsSet(boolean value) { + if (!value) { + this.title = null; + } + } + + public String getDescription() { + return this.description; + } + + public InteractionTask setDescription(String description) { + this.description = description; + return this; + } + + public void unsetDescription() { + this.description = null; + } + + /** Returns true if field description is set (has been assigned a value) and false otherwise */ + public boolean isSetDescription() { + return this.description != null; + } + + public void setDescriptionIsSet(boolean value) { + if (!value) { + this.description = null; + } + } + + public String getPlugin() { + return this.plugin; + } + + public InteractionTask setPlugin(String plugin) { + this.plugin = plugin; + return this; + } + + public void unsetPlugin() { + this.plugin = null; + } + + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } + + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case IID: + if (value == null) { + unsetIid(); + } else { + setIid((Integer) value); + } + break; + + case INPUT: + if (value == null) { + unsetInput(); + } else { + setInput((Input) value); + } + break; + + case STRUCTURE: + if (value == null) { + unsetStructure(); + } else { + setStructure((List<String>) value); + } + break; + + case PRESET: + if (value == null) { + unsetPreset(); + } else { + setPreset((List<String>) value); + } + break; + + case OUTPUT: + if (value == null) { + unsetOutput(); + } else { + setOutput((Output) value); + } + break; + + case DATA: + if (value == null) { + unsetData(); + } else { + setData((List<String>) value); + } + break; + + case TITLE: + if (value == null) { + unsetTitle(); + } else { + setTitle((String) value); + } + break; + + case DESCRIPTION: + if (value == null) { + unsetDescription(); + } else { + setDescription((String) value); + } + break; + + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case IID: + return getIid(); + + case INPUT: + return getInput(); + + case STRUCTURE: + return getStructure(); + + case PRESET: + return getPreset(); + + case OUTPUT: + return getOutput(); + + case DATA: + return getData(); + + case TITLE: + return getTitle(); + + case DESCRIPTION: + return getDescription(); + + case PLUGIN: + return getPlugin(); + + } + 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 IID: + return isSetIid(); + case INPUT: + return isSetInput(); + case STRUCTURE: + return isSetStructure(); + case PRESET: + return isSetPreset(); + case OUTPUT: + return isSetOutput(); + case DATA: + return isSetData(); + case TITLE: + return isSetTitle(); + case DESCRIPTION: + return isSetDescription(); + case PLUGIN: + return isSetPlugin(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof InteractionTask) + return this.equals((InteractionTask) that); + return false; + } + + public boolean equals(InteractionTask that) { + if (that == null) + return false; + + boolean this_present_iid = true; + boolean that_present_iid = true; + if (this_present_iid || that_present_iid) { + if (!(this_present_iid && that_present_iid)) + return false; + if (this.iid != that.iid) + return false; + } + + boolean this_present_input = true && this.isSetInput(); + boolean that_present_input = true && that.isSetInput(); + if (this_present_input || that_present_input) { + if (!(this_present_input && that_present_input)) + return false; + if (!this.input.equals(that.input)) + return false; + } + + boolean this_present_structure = true && this.isSetStructure(); + boolean that_present_structure = true && that.isSetStructure(); + if (this_present_structure || that_present_structure) { + if (!(this_present_structure && that_present_structure)) + return false; + if (!this.structure.equals(that.structure)) + return false; + } + + boolean this_present_preset = true && this.isSetPreset(); + boolean that_present_preset = true && that.isSetPreset(); + if (this_present_preset || that_present_preset) { + if (!(this_present_preset && that_present_preset)) + return false; + if (!this.preset.equals(that.preset)) + return false; + } + + boolean this_present_output = true && this.isSetOutput(); + boolean that_present_output = true && that.isSetOutput(); + if (this_present_output || that_present_output) { + if (!(this_present_output && that_present_output)) + return false; + if (!this.output.equals(that.output)) + return false; + } + + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + return false; + } + + boolean this_present_title = true && this.isSetTitle(); + boolean that_present_title = true && that.isSetTitle(); + if (this_present_title || that_present_title) { + if (!(this_present_title && that_present_title)) + return false; + if (!this.title.equals(that.title)) + return false; + } + + boolean this_present_description = true && this.isSetDescription(); + boolean that_present_description = true && that.isSetDescription(); + if (this_present_description || that_present_description) { + if (!(this_present_description && that_present_description)) + return false; + if (!this.description.equals(that.description)) + return false; + } + + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_iid = true; + list.add(present_iid); + if (present_iid) + list.add(iid); + + boolean present_input = true && (isSetInput()); + list.add(present_input); + if (present_input) + list.add(input.getValue()); + + boolean present_structure = true && (isSetStructure()); + list.add(present_structure); + if (present_structure) + list.add(structure); + + boolean present_preset = true && (isSetPreset()); + list.add(present_preset); + if (present_preset) + list.add(preset); + + boolean present_output = true && (isSetOutput()); + list.add(present_output); + if (present_output) + list.add(output.getValue()); + + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); + + boolean present_title = true && (isSetTitle()); + list.add(present_title); + if (present_title) + list.add(title); + + boolean present_description = true && (isSetDescription()); + list.add(present_description); + if (present_description) + list.add(description); + + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); + + return list.hashCode(); + } + + @Override + public int compareTo(InteractionTask other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetIid()).compareTo(other.isSetIid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetIid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.iid, other.iid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetInput()).compareTo(other.isSetInput()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetInput()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.input, other.input); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetStructure()).compareTo(other.isSetStructure()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStructure()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.structure, other.structure); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPreset()).compareTo(other.isSetPreset()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPreset()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.preset, other.preset); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOutput()).compareTo(other.isSetOutput()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOutput()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.output, other.output); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetTitle()).compareTo(other.isSetTitle()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTitle()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.title, other.title); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDescription()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + 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("InteractionTask("); + boolean first = true; + + sb.append("iid:"); + sb.append(this.iid); + first = false; + if (!first) sb.append(", "); + sb.append("input:"); + if (this.input == null) { + sb.append("null"); + } else { + sb.append(this.input); + } + first = false; + if (!first) sb.append(", "); + sb.append("structure:"); + if (this.structure == null) { + sb.append("null"); + } else { + sb.append(this.structure); + } + first = false; + if (!first) sb.append(", "); + sb.append("preset:"); + if (this.preset == null) { + sb.append("null"); + } else { + sb.append(this.preset); + } + first = false; + if (!first) sb.append(", "); + sb.append("output:"); + if (this.output == null) { + sb.append("null"); + } else { + sb.append(this.output); + } + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + sb.append(this.data); + } + first = false; + if (!first) sb.append(", "); + sb.append("title:"); + if (this.title == null) { + sb.append("null"); + } else { + sb.append(this.title); + } + first = false; + if (!first) sb.append(", "); + sb.append("description:"); + if (this.description == null) { + sb.append("null"); + } else { + sb.append(this.description); + } + first = false; + if (!first) sb.append(", "); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 InteractionTaskStandardSchemeFactory implements SchemeFactory { + public InteractionTaskStandardScheme getScheme() { + return new InteractionTaskStandardScheme(); + } + } + + private static class InteractionTaskStandardScheme extends StandardScheme<InteractionTask> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, InteractionTask 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: // IID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.iid = iprot.readI32(); + struct.setIidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // INPUT + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.input = org.pyload.thrift.Input.findByValue(iprot.readI32()); + struct.setInputIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // STRUCTURE + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list24 = iprot.readListBegin(); + struct.structure = new ArrayList<String>(_list24.size); + String _elem25; + for (int _i26 = 0; _i26 < _list24.size; ++_i26) { + _elem25 = iprot.readString(); + struct.structure.add(_elem25); + } + iprot.readListEnd(); + } + struct.setStructureIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // PRESET + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list27 = iprot.readListBegin(); + struct.preset = new ArrayList<String>(_list27.size); + String _elem28; + for (int _i29 = 0; _i29 < _list27.size; ++_i29) { + _elem28 = iprot.readString(); + struct.preset.add(_elem28); + } + iprot.readListEnd(); + } + struct.setPresetIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // OUTPUT + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.output = org.pyload.thrift.Output.findByValue(iprot.readI32()); + struct.setOutputIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list30 = iprot.readListBegin(); + struct.data = new ArrayList<String>(_list30.size); + String _elem31; + for (int _i32 = 0; _i32 < _list30.size; ++_i32) { + _elem31 = iprot.readString(); + struct.data.add(_elem31); + } + iprot.readListEnd(); + } + struct.setDataIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // TITLE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.title = iprot.readString(); + struct.setTitleIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // DESCRIPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(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, InteractionTask struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(IID_FIELD_DESC); + oprot.writeI32(struct.iid); + oprot.writeFieldEnd(); + if (struct.input != null) { + oprot.writeFieldBegin(INPUT_FIELD_DESC); + oprot.writeI32(struct.input.getValue()); + oprot.writeFieldEnd(); + } + if (struct.structure != null) { + oprot.writeFieldBegin(STRUCTURE_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.structure.size())); + for (String _iter33 : struct.structure) { + oprot.writeString(_iter33); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.preset != null) { + oprot.writeFieldBegin(PRESET_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.preset.size())); + for (String _iter34 : struct.preset) { + oprot.writeString(_iter34); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.output != null) { + oprot.writeFieldBegin(OUTPUT_FIELD_DESC); + oprot.writeI32(struct.output.getValue()); + oprot.writeFieldEnd(); + } + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.data.size())); + for (String _iter35 : struct.data) { + oprot.writeString(_iter35); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.title != null) { + oprot.writeFieldBegin(TITLE_FIELD_DESC); + oprot.writeString(struct.title); + oprot.writeFieldEnd(); + } + if (struct.description != null) { + oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC); + oprot.writeString(struct.description); + oprot.writeFieldEnd(); + } + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class InteractionTaskTupleSchemeFactory implements SchemeFactory { + public InteractionTaskTupleScheme getScheme() { + return new InteractionTaskTupleScheme(); + } + } + + private static class InteractionTaskTupleScheme extends TupleScheme<InteractionTask> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, InteractionTask struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetIid()) { + optionals.set(0); + } + if (struct.isSetInput()) { + optionals.set(1); + } + if (struct.isSetStructure()) { + optionals.set(2); + } + if (struct.isSetPreset()) { + optionals.set(3); + } + if (struct.isSetOutput()) { + optionals.set(4); + } + if (struct.isSetData()) { + optionals.set(5); + } + if (struct.isSetTitle()) { + optionals.set(6); + } + if (struct.isSetDescription()) { + optionals.set(7); + } + if (struct.isSetPlugin()) { + optionals.set(8); + } + oprot.writeBitSet(optionals, 9); + if (struct.isSetIid()) { + oprot.writeI32(struct.iid); + } + if (struct.isSetInput()) { + oprot.writeI32(struct.input.getValue()); + } + if (struct.isSetStructure()) { + { + oprot.writeI32(struct.structure.size()); + for (String _iter36 : struct.structure) { + oprot.writeString(_iter36); + } + } + } + if (struct.isSetPreset()) { + { + oprot.writeI32(struct.preset.size()); + for (String _iter37 : struct.preset) { + oprot.writeString(_iter37); + } + } + } + if (struct.isSetOutput()) { + oprot.writeI32(struct.output.getValue()); + } + if (struct.isSetData()) { + { + oprot.writeI32(struct.data.size()); + for (String _iter38 : struct.data) { + oprot.writeString(_iter38); + } + } + } + if (struct.isSetTitle()) { + oprot.writeString(struct.title); + } + if (struct.isSetDescription()) { + oprot.writeString(struct.description); + } + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, InteractionTask struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(9); + if (incoming.get(0)) { + struct.iid = iprot.readI32(); + struct.setIidIsSet(true); + } + if (incoming.get(1)) { + struct.input = org.pyload.thrift.Input.findByValue(iprot.readI32()); + struct.setInputIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list39 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.structure = new ArrayList<String>(_list39.size); + String _elem40; + for (int _i41 = 0; _i41 < _list39.size; ++_i41) { + _elem40 = iprot.readString(); + struct.structure.add(_elem40); + } + } + struct.setStructureIsSet(true); + } + if (incoming.get(3)) { + { + org.apache.thrift.protocol.TList _list42 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.preset = new ArrayList<String>(_list42.size); + String _elem43; + for (int _i44 = 0; _i44 < _list42.size; ++_i44) { + _elem43 = iprot.readString(); + struct.preset.add(_elem43); + } + } + struct.setPresetIsSet(true); + } + if (incoming.get(4)) { + struct.output = org.pyload.thrift.Output.findByValue(iprot.readI32()); + struct.setOutputIsSet(true); + } + if (incoming.get(5)) { + { + org.apache.thrift.protocol.TList _list45 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.data = new ArrayList<String>(_list45.size); + String _elem46; + for (int _i47 = 0; _i47 < _list45.size; ++_i47) { + _elem46 = iprot.readString(); + struct.data.add(_elem46); + } + } + struct.setDataIsSet(true); + } + if (incoming.get(6)) { + struct.title = iprot.readString(); + struct.setTitleIsSet(true); + } + if (incoming.get(7)) { + struct.description = iprot.readString(); + struct.setDescriptionIsSet(true); + } + if (incoming.get(8)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + } + } + +} + diff --git a/app/src/main/java/org/pyload/thrift/OnlineCheck.java b/app/src/main/java/org/pyload/thrift/OnlineCheck.java index 2f6c5bd..b6a2ec0 100644 --- a/app/src/main/java/org/pyload/thrift/OnlineCheck.java +++ b/app/src/main/java/org/pyload/thrift/OnlineCheck.java @@ -1,546 +1,587 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class OnlineCheck implements org.apache.thrift.TBase<OnlineCheck, OnlineCheck._Fields>, java.io.Serializable, Cloneable, Comparable<OnlineCheck>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("OnlineCheck"); + + private static final org.apache.thrift.protocol.TField RID_FIELD_DESC = new org.apache.thrift.protocol.TField("rid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", 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 OnlineCheckStandardSchemeFactory()); + schemes.put(TupleScheme.class, new OnlineCheckTupleSchemeFactory()); + } + + public int rid; // required + public Map<String, OnlineStatus> data; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(rid); + out.writeMap(data); + } + + @Override + public int describeContents() { + return 0; + } + + public OnlineCheck(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.rid = in.readInt(); + this.data = new HashMap<String, OnlineStatus>(); + in.readMap(this.data, OnlineCheck.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<OnlineCheck> CREATOR = new android.os.Parcelable.Creator<OnlineCheck>() { + @Override + public OnlineCheck[] newArray(int size) { + return new OnlineCheck[size]; + } + + @Override + public OnlineCheck createFromParcel(android.os.Parcel in) { + return new OnlineCheck(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + RID((short) 1, "rid"), + DATA((short) 2, "data"); + + 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: // RID + return RID; + case 2: // DATA + return DATA; + default: + return null; + } + } -public class OnlineCheck implements org.apache.thrift.TBase<OnlineCheck, OnlineCheck._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("OnlineCheck"); + /** + * 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 static final org.apache.thrift.protocol.TField RID_FIELD_DESC = new org.apache.thrift.protocol.TField("rid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.MAP, (short)2); + private final short _thriftId; + private final String _fieldName; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new OnlineCheckStandardSchemeFactory()); - schemes.put(TupleScheme.class, new OnlineCheckTupleSchemeFactory()); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public int rid; // required - public Map<String,OnlineStatus> data; // required + public short getThriftFieldId() { + return _thriftId; + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - RID((short)1, "rid"), - DATA((short)2, "data"); + public String getFieldName() { + return _fieldName; + } + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + // isset id assignments + private static final int __RID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.RID, new org.apache.thrift.meta_data.FieldMetaData("rid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "ResultID"))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineStatus.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OnlineCheck.class, metaDataMap); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // RID - return RID; - case 2: // DATA - return DATA; - default: - return null; - } + public OnlineCheck() { } - /** - * 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; + public OnlineCheck( + int rid, + Map<String, OnlineStatus> data) { + this(); + this.rid = rid; + setRidIsSet(true); + this.data = data; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __RID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.RID, new org.apache.thrift.meta_data.FieldMetaData("rid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ResultID"))); - tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineStatus.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OnlineCheck.class, metaDataMap); - } - - public OnlineCheck() { - } - - public OnlineCheck( - int rid, - Map<String,OnlineStatus> data) - { - this(); - this.rid = rid; - setRidIsSet(true); - this.data = data; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public OnlineCheck(OnlineCheck other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.rid = other.rid; - if (other.isSetData()) { - Map<String,OnlineStatus> __this__data = new HashMap<String,OnlineStatus>(); - for (Map.Entry<String, OnlineStatus> other_element : other.data.entrySet()) { - - String other_element_key = other_element.getKey(); - OnlineStatus other_element_value = other_element.getValue(); - - String __this__data_copy_key = other_element_key; - - OnlineStatus __this__data_copy_value = new OnlineStatus(other_element_value); - - __this__data.put(__this__data_copy_key, __this__data_copy_value); - } - this.data = __this__data; - } - } - - public OnlineCheck deepCopy() { - return new OnlineCheck(this); - } - - @Override - public void clear() { - setRidIsSet(false); - this.rid = 0; - this.data = null; - } - - public int getRid() { - return this.rid; - } - - public OnlineCheck setRid(int rid) { - this.rid = rid; - setRidIsSet(true); - return this; - } - - public void unsetRid() { - __isset_bit_vector.clear(__RID_ISSET_ID); - } - - /** Returns true if field rid is set (has been assigned a value) and false otherwise */ - public boolean isSetRid() { - return __isset_bit_vector.get(__RID_ISSET_ID); - } - - public void setRidIsSet(boolean value) { - __isset_bit_vector.set(__RID_ISSET_ID, value); - } - - public int getDataSize() { - return (this.data == null) ? 0 : this.data.size(); - } - - public void putToData(String key, OnlineStatus val) { - if (this.data == null) { - this.data = new HashMap<String,OnlineStatus>(); - } - this.data.put(key, val); - } - - public Map<String,OnlineStatus> getData() { - return this.data; - } - - public OnlineCheck setData(Map<String,OnlineStatus> data) { - this.data = data; - return this; - } - - public void unsetData() { - this.data = null; - } - - /** Returns true if field data is set (has been assigned a value) and false otherwise */ - public boolean isSetData() { - return this.data != null; - } - - public void setDataIsSet(boolean value) { - if (!value) { - this.data = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case RID: - if (value == null) { - unsetRid(); - } else { - setRid((Integer)value); - } - break; - - case DATA: - if (value == null) { - unsetData(); - } else { - setData((Map<String,OnlineStatus>)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case RID: - return Integer.valueOf(getRid()); - - case DATA: - return getData(); - - } - 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 RID: - return isSetRid(); - case DATA: - return isSetData(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof OnlineCheck) - return this.equals((OnlineCheck)that); - return false; - } - - public boolean equals(OnlineCheck that) { - if (that == null) - return false; - - boolean this_present_rid = true; - boolean that_present_rid = true; - if (this_present_rid || that_present_rid) { - if (!(this_present_rid && that_present_rid)) - return false; - if (this.rid != that.rid) - return false; + public OnlineCheck(OnlineCheck other) { + __isset_bitfield = other.__isset_bitfield; + this.rid = other.rid; + if (other.isSetData()) { + Map<String, OnlineStatus> __this__data = new HashMap<String, OnlineStatus>(other.data.size()); + for (Map.Entry<String, OnlineStatus> other_element : other.data.entrySet()) { + + String other_element_key = other_element.getKey(); + OnlineStatus other_element_value = other_element.getValue(); + + String __this__data_copy_key = other_element_key; + + OnlineStatus __this__data_copy_value = new OnlineStatus(other_element_value); + + __this__data.put(__this__data_copy_key, __this__data_copy_value); + } + this.data = __this__data; + } } - boolean this_present_data = true && this.isSetData(); - boolean that_present_data = true && that.isSetData(); - if (this_present_data || that_present_data) { - if (!(this_present_data && that_present_data)) - return false; - if (!this.data.equals(that.data)) - return false; + public OnlineCheck deepCopy() { + return new OnlineCheck(this); } - return true; - } + @Override + public void clear() { + setRidIsSet(false); + this.rid = 0; + this.data = null; + } - @Override - public int hashCode() { - return 0; - } - - public int compareTo(OnlineCheck other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - OnlineCheck typedOther = (OnlineCheck)other; - - lastComparison = Boolean.valueOf(isSetRid()).compareTo(typedOther.isSetRid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetRid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rid, typedOther.rid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetData()).compareTo(typedOther.isSetData()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetData()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, typedOther.data); - 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("OnlineCheck("); - boolean first = true; - - sb.append("rid:"); - sb.append(this.rid); - first = false; - if (!first) sb.append(", "); - sb.append("data:"); - if (this.data == null) { - sb.append("null"); - } else { - sb.append(this.data); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class OnlineCheckStandardSchemeFactory implements SchemeFactory { - public OnlineCheckStandardScheme getScheme() { - return new OnlineCheckStandardScheme(); - } - } - - private static class OnlineCheckStandardScheme extends StandardScheme<OnlineCheck> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, OnlineCheck 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: // RID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.rid = iprot.readI32(); - struct.setRidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // DATA - if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { - { - org.apache.thrift.protocol.TMap _map50 = iprot.readMapBegin(); - struct.data = new HashMap<String,OnlineStatus>(2*_map50.size); - for (int _i51 = 0; _i51 < _map50.size; ++_i51) - { - String _key52; // required - OnlineStatus _val53; // required - _key52 = iprot.readString(); - _val53 = new OnlineStatus(); - _val53.read(iprot); - struct.data.put(_key52, _val53); + public int getRid() { + return this.rid; + } + + public OnlineCheck setRid(int rid) { + this.rid = rid; + setRidIsSet(true); + return this; + } + + public void unsetRid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __RID_ISSET_ID); + } + + /** Returns true if field rid is set (has been assigned a value) and false otherwise */ + public boolean isSetRid() { + return EncodingUtils.testBit(__isset_bitfield, __RID_ISSET_ID); + } + + public void setRidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __RID_ISSET_ID, value); + } + + public int getDataSize() { + return (this.data == null) ? 0 : this.data.size(); + } + + public void putToData(String key, OnlineStatus val) { + if (this.data == null) { + this.data = new HashMap<String, OnlineStatus>(); + } + this.data.put(key, val); + } + + public Map<String, OnlineStatus> getData() { + return this.data; + } + + public OnlineCheck setData(Map<String, OnlineStatus> data) { + this.data = data; + return this; + } + + public void unsetData() { + this.data = null; + } + + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } + + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RID: + if (value == null) { + unsetRid(); + } else { + setRid((Integer) value); } - iprot.readMapEnd(); - } - struct.setDataIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + break; + + case DATA: + if (value == null) { + unsetData(); + } else { + setData((Map<String, OnlineStatus>) value); + } + break; + } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RID: + return getRid(); - // check for required fields of primitive type, which can't be checked in the validate method - struct.validate(); + case DATA: + return getData(); + + } + throw new IllegalStateException(); } - public void write(org.apache.thrift.protocol.TProtocol oprot, OnlineCheck struct) throws org.apache.thrift.TException { - struct.validate(); + /** 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(); + } - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(RID_FIELD_DESC); - oprot.writeI32(struct.rid); - oprot.writeFieldEnd(); - if (struct.data != null) { - oprot.writeFieldBegin(DATA_FIELD_DESC); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.data.size())); - for (Map.Entry<String, OnlineStatus> _iter54 : struct.data.entrySet()) - { - oprot.writeString(_iter54.getKey()); - _iter54.getValue().write(oprot); - } - oprot.writeMapEnd(); + switch (field) { + case RID: + return isSetRid(); + case DATA: + return isSetData(); } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); + throw new IllegalStateException(); } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof OnlineCheck) + return this.equals((OnlineCheck) that); + return false; + } - private static class OnlineCheckTupleSchemeFactory implements SchemeFactory { - public OnlineCheckTupleScheme getScheme() { - return new OnlineCheckTupleScheme(); + public boolean equals(OnlineCheck that) { + if (that == null) + return false; + + boolean this_present_rid = true; + boolean that_present_rid = true; + if (this_present_rid || that_present_rid) { + if (!(this_present_rid && that_present_rid)) + return false; + if (this.rid != that.rid) + return false; + } + + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + return false; + } + + return true; } - } - private static class OnlineCheckTupleScheme extends TupleScheme<OnlineCheck> { + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_rid = true; + list.add(present_rid); + if (present_rid) + list.add(rid); + + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); + + return list.hashCode(); + } @Override - public void write(org.apache.thrift.protocol.TProtocol prot, OnlineCheck struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetRid()) { - optionals.set(0); - } - if (struct.isSetData()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetRid()) { - oprot.writeI32(struct.rid); - } - if (struct.isSetData()) { - { - oprot.writeI32(struct.data.size()); - for (Map.Entry<String, OnlineStatus> _iter55 : struct.data.entrySet()) - { - oprot.writeString(_iter55.getKey()); - _iter55.getValue().write(oprot); - } - } - } + public int compareTo(OnlineCheck other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRid()).compareTo(other.isSetRid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rid, other.rid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + 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 void read(org.apache.thrift.protocol.TProtocol prot, OnlineCheck struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.rid = iprot.readI32(); - struct.setRidIsSet(true); - } - if (incoming.get(1)) { - { - org.apache.thrift.protocol.TMap _map56 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.data = new HashMap<String,OnlineStatus>(2*_map56.size); - for (int _i57 = 0; _i57 < _map56.size; ++_i57) - { - String _key58; // required - OnlineStatus _val59; // required - _key58 = iprot.readString(); - _val59 = new OnlineStatus(); - _val59.read(iprot); - struct.data.put(_key58, _val59); - } - } - struct.setDataIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("OnlineCheck("); + boolean first = true; + + sb.append("rid:"); + sb.append(this.rid); + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + sb.append(this.data); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 OnlineCheckStandardSchemeFactory implements SchemeFactory { + public OnlineCheckStandardScheme getScheme() { + return new OnlineCheckStandardScheme(); + } + } + + private static class OnlineCheckStandardScheme extends StandardScheme<OnlineCheck> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, OnlineCheck 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: // RID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.rid = iprot.readI32(); + struct.setRidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map74 = iprot.readMapBegin(); + struct.data = new HashMap<String, OnlineStatus>(2 * _map74.size); + String _key75; + OnlineStatus _val76; + for (int _i77 = 0; _i77 < _map74.size; ++_i77) { + _key75 = iprot.readString(); + _val76 = new OnlineStatus(); + _val76.read(iprot); + struct.data.put(_key75, _val76); + } + iprot.readMapEnd(); + } + struct.setDataIsSet(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, OnlineCheck struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(RID_FIELD_DESC); + oprot.writeI32(struct.rid); + oprot.writeFieldEnd(); + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, struct.data.size())); + for (Map.Entry<String, OnlineStatus> _iter78 : struct.data.entrySet()) { + oprot.writeString(_iter78.getKey()); + _iter78.getValue().write(oprot); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class OnlineCheckTupleSchemeFactory implements SchemeFactory { + public OnlineCheckTupleScheme getScheme() { + return new OnlineCheckTupleScheme(); + } + } + + private static class OnlineCheckTupleScheme extends TupleScheme<OnlineCheck> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, OnlineCheck struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRid()) { + optionals.set(0); + } + if (struct.isSetData()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetRid()) { + oprot.writeI32(struct.rid); + } + if (struct.isSetData()) { + { + oprot.writeI32(struct.data.size()); + for (Map.Entry<String, OnlineStatus> _iter79 : struct.data.entrySet()) { + oprot.writeString(_iter79.getKey()); + _iter79.getValue().write(oprot); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, OnlineCheck struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.rid = iprot.readI32(); + struct.setRidIsSet(true); + } + if (incoming.get(1)) { + { + org.apache.thrift.protocol.TMap _map80 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.data = new HashMap<String, OnlineStatus>(2 * _map80.size); + String _key81; + OnlineStatus _val82; + for (int _i83 = 0; _i83 < _map80.size; ++_i83) { + _key81 = iprot.readString(); + _val82 = new OnlineStatus(); + _val82.read(iprot); + struct.data.put(_key81, _val82); + } + } + struct.setDataIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/OnlineStatus.java b/app/src/main/java/org/pyload/thrift/OnlineStatus.java index 9cbd714..d1328f5 100644 --- a/app/src/main/java/org/pyload/thrift/OnlineStatus.java +++ b/app/src/main/java/org/pyload/thrift/OnlineStatus.java @@ -1,797 +1,862 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class OnlineStatus implements org.apache.thrift.TBase<OnlineStatus, OnlineStatus._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("OnlineStatus"); - - 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 PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PACKAGENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("packagename", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short)4); - private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short)5); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new OnlineStatusStandardSchemeFactory()); - schemes.put(TupleScheme.class, new OnlineStatusTupleSchemeFactory()); - } - - public String name; // required - public String plugin; // required - public String packagename; // required - /** - * - * @see DownloadStatus - */ - public DownloadStatus status; // required - public long size; // 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"), - PLUGIN((short)2, "plugin"), - PACKAGENAME((short)3, "packagename"), +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class OnlineStatus implements org.apache.thrift.TBase<OnlineStatus, OnlineStatus._Fields>, java.io.Serializable, Cloneable, Comparable<OnlineStatus>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("OnlineStatus"); + + 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 PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField PACKAGENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("packagename", org.apache.thrift.protocol.TType.STRING, (short) 3); + private static final org.apache.thrift.protocol.TField STATUS_FIELD_DESC = new org.apache.thrift.protocol.TField("status", org.apache.thrift.protocol.TType.I32, (short) 4); + private static final org.apache.thrift.protocol.TField SIZE_FIELD_DESC = new org.apache.thrift.protocol.TField("size", org.apache.thrift.protocol.TType.I64, (short) 5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new OnlineStatusStandardSchemeFactory()); + schemes.put(TupleScheme.class, new OnlineStatusTupleSchemeFactory()); + } + + public String name; // required + public String plugin; // required + public String packagename; // required /** - * + * * @see DownloadStatus */ - STATUS((short)4, "status"), - SIZE((short)5, "size"); + public DownloadStatus status; // required + public long size; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeString(name); + out.writeString(plugin); + out.writeString(packagename); + out.writeInt(status.getValue()); + out.writeLong(size); + } + + @Override + public int describeContents() { + return 0; + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + public OnlineStatus(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.name = in.readString(); + this.plugin = in.readString(); + this.packagename = in.readString(); + this.status = DownloadStatus.findByValue(in.readInt()); + this.size = in.readLong(); + } + + public static final android.os.Parcelable.Creator<OnlineStatus> CREATOR = new android.os.Parcelable.Creator<OnlineStatus>() { + @Override + public OnlineStatus[] newArray(int size) { + return new OnlineStatus[size]; + } + + @Override + public OnlineStatus createFromParcel(android.os.Parcel in) { + return new OnlineStatus(in); + } + }; + + /** 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"), + PLUGIN((short) 2, "plugin"), + PACKAGENAME((short) 3, "packagename"), + /** + * + * @see DownloadStatus + */ + STATUS((short) 4, "status"), + SIZE((short) 5, "size"); + + 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: // PLUGIN + return PLUGIN; + case 3: // PACKAGENAME + return PACKAGENAME; + case 4: // STATUS + return STATUS; + case 5: // SIZE + return SIZE; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SIZE_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.PACKAGENAME, new org.apache.thrift.meta_data.FieldMetaData("packagename", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); + tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OnlineStatus.class, metaDataMap); + } + + public OnlineStatus() { + } + + public OnlineStatus( + String name, + String plugin, + String packagename, + DownloadStatus status, + long size) { + this(); + this.name = name; + this.plugin = plugin; + this.packagename = packagename; + this.status = status; + this.size = size; + setSizeIsSet(true); } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // NAME - return NAME; - case 2: // PLUGIN - return PLUGIN; - case 3: // PACKAGENAME - return PACKAGENAME; - case 4: // STATUS - return STATUS; - case 5: // SIZE - return SIZE; - default: - return null; - } + public OnlineStatus(OnlineStatus other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetPackagename()) { + this.packagename = other.packagename; + } + if (other.isSetStatus()) { + this.status = other.status; + } + this.size = other.size; + } + + public OnlineStatus deepCopy() { + return new OnlineStatus(this); + } + + @Override + public void clear() { + this.name = null; + this.plugin = null; + this.packagename = null; + this.status = null; + setSizeIsSet(false); + this.size = 0; + } + + public String getName() { + return this.name; + } + + public OnlineStatus setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getPlugin() { + return this.plugin; + } + + public OnlineStatus setPlugin(String plugin) { + this.plugin = plugin; + return this; + } + + public void unsetPlugin() { + this.plugin = null; + } + + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } + + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } + + public String getPackagename() { + return this.packagename; + } + + public OnlineStatus setPackagename(String packagename) { + this.packagename = packagename; + return this; + } + + public void unsetPackagename() { + this.packagename = null; + } + + /** Returns true if field packagename is set (has been assigned a value) and false otherwise */ + public boolean isSetPackagename() { + return this.packagename != null; + } + + public void setPackagenameIsSet(boolean value) { + if (!value) { + this.packagename = null; + } } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * + * @see DownloadStatus */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public DownloadStatus getStatus() { + return this.status; } /** - * Find the _Fields constant that matches name, or null if its not found. + * + * @see DownloadStatus */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __SIZE_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.PACKAGENAME, new org.apache.thrift.meta_data.FieldMetaData("packagename", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.STATUS, new org.apache.thrift.meta_data.FieldMetaData("status", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, DownloadStatus.class))); - tmpMap.put(_Fields.SIZE, new org.apache.thrift.meta_data.FieldMetaData("size", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(OnlineStatus.class, metaDataMap); - } - - public OnlineStatus() { - } - - public OnlineStatus( - String name, - String plugin, - String packagename, - DownloadStatus status, - long size) - { - this(); - this.name = name; - this.plugin = plugin; - this.packagename = packagename; - this.status = status; - this.size = size; - setSizeIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public OnlineStatus(OnlineStatus other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetPackagename()) { - this.packagename = other.packagename; - } - if (other.isSetStatus()) { - this.status = other.status; - } - this.size = other.size; - } - - public OnlineStatus deepCopy() { - return new OnlineStatus(this); - } - - @Override - public void clear() { - this.name = null; - this.plugin = null; - this.packagename = null; - this.status = null; - setSizeIsSet(false); - this.size = 0; - } - - public String getName() { - return this.name; - } - - public OnlineStatus setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getPlugin() { - return this.plugin; - } - - public OnlineStatus setPlugin(String plugin) { - this.plugin = plugin; - return this; - } - - public void unsetPlugin() { - this.plugin = null; - } - - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } - - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } - - public String getPackagename() { - return this.packagename; - } - - public OnlineStatus setPackagename(String packagename) { - this.packagename = packagename; - return this; - } - - public void unsetPackagename() { - this.packagename = null; - } - - /** Returns true if field packagename is set (has been assigned a value) and false otherwise */ - public boolean isSetPackagename() { - return this.packagename != null; - } - - public void setPackagenameIsSet(boolean value) { - if (!value) { - this.packagename = null; - } - } - - /** - * - * @see DownloadStatus - */ - public DownloadStatus getStatus() { - return this.status; - } - - /** - * - * @see DownloadStatus - */ - public OnlineStatus setStatus(DownloadStatus status) { - this.status = status; - return this; - } - - public void unsetStatus() { - this.status = null; - } - - /** Returns true if field status is set (has been assigned a value) and false otherwise */ - public boolean isSetStatus() { - return this.status != null; - } - - public void setStatusIsSet(boolean value) { - if (!value) { - this.status = null; - } - } - - public long getSize() { - return this.size; - } - - public OnlineStatus setSize(long size) { - this.size = size; - setSizeIsSet(true); - return this; - } - - public void unsetSize() { - __isset_bit_vector.clear(__SIZE_ISSET_ID); - } - - /** Returns true if field size is set (has been assigned a value) and false otherwise */ - public boolean isSetSize() { - return __isset_bit_vector.get(__SIZE_ISSET_ID); - } - - public void setSizeIsSet(boolean value) { - __isset_bit_vector.set(__SIZE_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); - } - break; - - case PACKAGENAME: - if (value == null) { - unsetPackagename(); - } else { - setPackagename((String)value); - } - break; - - case STATUS: - if (value == null) { - unsetStatus(); - } else { - setStatus((DownloadStatus)value); - } - break; - - case SIZE: - if (value == null) { - unsetSize(); - } else { - setSize((Long)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case NAME: - return getName(); - - case PLUGIN: - return getPlugin(); - - case PACKAGENAME: - return getPackagename(); - - case STATUS: - return getStatus(); - - case SIZE: - return Long.valueOf(getSize()); - - } - 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 PLUGIN: - return isSetPlugin(); - case PACKAGENAME: - return isSetPackagename(); - case STATUS: - return isSetStatus(); - case SIZE: - return isSetSize(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof OnlineStatus) - return this.equals((OnlineStatus)that); - return false; - } - - public boolean equals(OnlineStatus 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; + public OnlineStatus setStatus(DownloadStatus status) { + this.status = status; + return this; } - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; + public void unsetStatus() { + this.status = null; } - boolean this_present_packagename = true && this.isSetPackagename(); - boolean that_present_packagename = true && that.isSetPackagename(); - if (this_present_packagename || that_present_packagename) { - if (!(this_present_packagename && that_present_packagename)) - return false; - if (!this.packagename.equals(that.packagename)) - return false; + /** Returns true if field status is set (has been assigned a value) and false otherwise */ + public boolean isSetStatus() { + return this.status != null; } - boolean this_present_status = true && this.isSetStatus(); - boolean that_present_status = true && that.isSetStatus(); - if (this_present_status || that_present_status) { - if (!(this_present_status && that_present_status)) - return false; - if (!this.status.equals(that.status)) - return false; + public void setStatusIsSet(boolean value) { + if (!value) { + this.status = null; + } } - boolean this_present_size = true; - boolean that_present_size = true; - if (this_present_size || that_present_size) { - if (!(this_present_size && that_present_size)) - return false; - if (this.size != that.size) + public long getSize() { + return this.size; + } + + public OnlineStatus setSize(long size) { + this.size = size; + setSizeIsSet(true); + return this; + } + + public void unsetSize() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + /** Returns true if field size is set (has been assigned a value) and false otherwise */ + public boolean isSetSize() { + return EncodingUtils.testBit(__isset_bitfield, __SIZE_ISSET_ID); + } + + public void setSizeIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SIZE_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + case PACKAGENAME: + if (value == null) { + unsetPackagename(); + } else { + setPackagename((String) value); + } + break; + + case STATUS: + if (value == null) { + unsetStatus(); + } else { + setStatus((DownloadStatus) value); + } + break; + + case SIZE: + if (value == null) { + unsetSize(); + } else { + setSize((Long) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case PLUGIN: + return getPlugin(); + + case PACKAGENAME: + return getPackagename(); + + case STATUS: + return getStatus(); + + case SIZE: + return getSize(); + + } + 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 PLUGIN: + return isSetPlugin(); + case PACKAGENAME: + return isSetPackagename(); + case STATUS: + return isSetStatus(); + case SIZE: + return isSetSize(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof OnlineStatus) + return this.equals((OnlineStatus) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(OnlineStatus other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - OnlineStatus typedOther = (OnlineStatus)other; - - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPackagename()).compareTo(typedOther.isSetPackagename()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPackagename()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packagename, typedOther.packagename); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetStatus()).compareTo(typedOther.isSetStatus()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetStatus()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, typedOther.status); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSize()).compareTo(typedOther.isSetSize()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSize()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, typedOther.size); - 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("OnlineStatus("); - boolean first = true; - - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("packagename:"); - if (this.packagename == null) { - sb.append("null"); - } else { - sb.append(this.packagename); - } - first = false; - if (!first) sb.append(", "); - sb.append("status:"); - if (this.status == null) { - sb.append("null"); - } else { - sb.append(this.status); - } - first = false; - if (!first) sb.append(", "); - sb.append("size:"); - sb.append(this.size); - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class OnlineStatusStandardSchemeFactory implements SchemeFactory { - public OnlineStatusStandardScheme getScheme() { - return new OnlineStatusStandardScheme(); - } - } - - private static class OnlineStatusStandardScheme extends StandardScheme<OnlineStatus> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, OnlineStatus 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); + public boolean equals(OnlineStatus 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_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + boolean this_present_packagename = true && this.isSetPackagename(); + boolean that_present_packagename = true && that.isSetPackagename(); + if (this_present_packagename || that_present_packagename) { + if (!(this_present_packagename && that_present_packagename)) + return false; + if (!this.packagename.equals(that.packagename)) + return false; + } + + boolean this_present_status = true && this.isSetStatus(); + boolean that_present_status = true && that.isSetStatus(); + if (this_present_status || that_present_status) { + if (!(this_present_status && that_present_status)) + return false; + if (!this.status.equals(that.status)) + return false; + } + + boolean this_present_size = true; + boolean that_present_size = true; + if (this_present_size || that_present_size) { + if (!(this_present_size && that_present_size)) + return false; + if (this.size != that.size) + 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_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); + + boolean present_packagename = true && (isSetPackagename()); + list.add(present_packagename); + if (present_packagename) + list.add(packagename); + + boolean present_status = true && (isSetStatus()); + list.add(present_status); + if (present_status) + list.add(status.getValue()); + + boolean present_size = true; + list.add(present_size); + if (present_size) + list.add(size); + + return list.hashCode(); + } + + @Override + public int compareTo(OnlineStatus 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; } - break; - case 2: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // PACKAGENAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.packagename = iprot.readString(); - struct.setPackagenameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPackagename()).compareTo(other.isSetPackagename()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPackagename()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.packagename, other.packagename); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // STATUS - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetStatus()).compareTo(other.isSetStatus()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetStatus()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.status, other.status); + if (lastComparison != 0) { + return lastComparison; } - break; - case 5: // SIZE - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetSize()).compareTo(other.isSetSize()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSize()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.size, other.size); + if (lastComparison != 0) { + return lastComparison; } - 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, OnlineStatus 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.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.packagename != null) { - oprot.writeFieldBegin(PACKAGENAME_FIELD_DESC); - oprot.writeString(struct.packagename); - oprot.writeFieldEnd(); - } - if (struct.status != null) { - oprot.writeFieldBegin(STATUS_FIELD_DESC); - oprot.writeI32(struct.status.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(SIZE_FIELD_DESC); - oprot.writeI64(struct.size); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class OnlineStatusTupleSchemeFactory implements SchemeFactory { - public OnlineStatusTupleScheme getScheme() { - return new OnlineStatusTupleScheme(); - } - } - - private static class OnlineStatusTupleScheme extends TupleScheme<OnlineStatus> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, OnlineStatus struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetName()) { - optionals.set(0); - } - if (struct.isSetPlugin()) { - optionals.set(1); - } - if (struct.isSetPackagename()) { - optionals.set(2); - } - if (struct.isSetStatus()) { - optionals.set(3); - } - if (struct.isSetSize()) { - optionals.set(4); - } - oprot.writeBitSet(optionals, 5); - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetPackagename()) { - oprot.writeString(struct.packagename); - } - if (struct.isSetStatus()) { - oprot.writeI32(struct.status.getValue()); - } - if (struct.isSetSize()) { - oprot.writeI64(struct.size); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, OnlineStatus struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(5); - if (incoming.get(0)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(1)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(2)) { - struct.packagename = iprot.readString(); - struct.setPackagenameIsSet(true); - } - if (incoming.get(3)) { - struct.status = DownloadStatus.findByValue(iprot.readI32()); - struct.setStatusIsSet(true); - } - if (incoming.get(4)) { - struct.size = iprot.readI64(); - struct.setSizeIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("OnlineStatus("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("packagename:"); + if (this.packagename == null) { + sb.append("null"); + } else { + sb.append(this.packagename); + } + first = false; + if (!first) sb.append(", "); + sb.append("status:"); + if (this.status == null) { + sb.append("null"); + } else { + sb.append(this.status); + } + first = false; + if (!first) sb.append(", "); + sb.append("size:"); + sb.append(this.size); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 OnlineStatusStandardSchemeFactory implements SchemeFactory { + public OnlineStatusStandardScheme getScheme() { + return new OnlineStatusStandardScheme(); + } + } + + private static class OnlineStatusStandardScheme extends StandardScheme<OnlineStatus> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, OnlineStatus 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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PACKAGENAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.packagename = iprot.readString(); + struct.setPackagenameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // STATUS + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // SIZE + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(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, OnlineStatus 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.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.packagename != null) { + oprot.writeFieldBegin(PACKAGENAME_FIELD_DESC); + oprot.writeString(struct.packagename); + oprot.writeFieldEnd(); + } + if (struct.status != null) { + oprot.writeFieldBegin(STATUS_FIELD_DESC); + oprot.writeI32(struct.status.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(SIZE_FIELD_DESC); + oprot.writeI64(struct.size); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class OnlineStatusTupleSchemeFactory implements SchemeFactory { + public OnlineStatusTupleScheme getScheme() { + return new OnlineStatusTupleScheme(); + } + } + + private static class OnlineStatusTupleScheme extends TupleScheme<OnlineStatus> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, OnlineStatus struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetPlugin()) { + optionals.set(1); + } + if (struct.isSetPackagename()) { + optionals.set(2); + } + if (struct.isSetStatus()) { + optionals.set(3); + } + if (struct.isSetSize()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetPackagename()) { + oprot.writeString(struct.packagename); + } + if (struct.isSetStatus()) { + oprot.writeI32(struct.status.getValue()); + } + if (struct.isSetSize()) { + oprot.writeI64(struct.size); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, OnlineStatus struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(2)) { + struct.packagename = iprot.readString(); + struct.setPackagenameIsSet(true); + } + if (incoming.get(3)) { + struct.status = org.pyload.thrift.DownloadStatus.findByValue(iprot.readI32()); + struct.setStatusIsSet(true); + } + if (incoming.get(4)) { + struct.size = iprot.readI64(); + struct.setSizeIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/Output.java b/app/src/main/java/org/pyload/thrift/Output.java new file mode 100644 index 0000000..26b89fc --- /dev/null +++ b/app/src/main/java/org/pyload/thrift/Output.java @@ -0,0 +1,45 @@ +/** + * Autogenerated by Thrift Compiler (0.9.3) + * <p> + * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING + * + * @generated + */ +package org.pyload.thrift; + + +public enum Output implements org.apache.thrift.TEnum { + CAPTCHA(1), + QUESTION(2), + NOTIFICATION(4); + + private final int value; + + private Output(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. + */ + public static Output findByValue(int value) { + switch (value) { + case 1: + return CAPTCHA; + case 2: + return QUESTION; + case 4: + return NOTIFICATION; + default: + return null; + } + } +} diff --git a/app/src/main/java/org/pyload/thrift/PackageData.java b/app/src/main/java/org/pyload/thrift/PackageData.java index ca0ce36..6e73a3a 100644 --- a/app/src/main/java/org/pyload/thrift/PackageData.java +++ b/app/src/main/java/org/pyload/thrift/PackageData.java @@ -1,1682 +1,1797 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class PackageData implements org.apache.thrift.TBase<PackageData, PackageData._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PackageData"); - - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField FOLDER_FIELD_DESC = new org.apache.thrift.protocol.TField("folder", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField SITE_FIELD_DESC = new org.apache.thrift.protocol.TField("site", org.apache.thrift.protocol.TType.STRING, (short)4); - private static final org.apache.thrift.protocol.TField PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short)5); - private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short)6); - private static final org.apache.thrift.protocol.TField ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("order", org.apache.thrift.protocol.TType.I16, (short)7); - private static final org.apache.thrift.protocol.TField LINKSDONE_FIELD_DESC = new org.apache.thrift.protocol.TField("linksdone", org.apache.thrift.protocol.TType.I16, (short)8); - private static final org.apache.thrift.protocol.TField SIZEDONE_FIELD_DESC = new org.apache.thrift.protocol.TField("sizedone", org.apache.thrift.protocol.TType.I64, (short)9); - private static final org.apache.thrift.protocol.TField SIZETOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("sizetotal", org.apache.thrift.protocol.TType.I64, (short)10); - private static final org.apache.thrift.protocol.TField LINKSTOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("linkstotal", org.apache.thrift.protocol.TType.I16, (short)11); - private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short)12); - private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short)13); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new PackageDataStandardSchemeFactory()); - schemes.put(TupleScheme.class, new PackageDataTupleSchemeFactory()); - } - - public int pid; // required - public String name; // required - public String folder; // required - public String site; // required - public String password; // required - /** - * - * @see Destination - */ - public Destination dest; // required - public short order; // required - public short linksdone; // required - public long sizedone; // required - public long sizetotal; // required - public short linkstotal; // required - public List<FileData> links; // required - public List<Integer> fids; // 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 { - PID((short)1, "pid"), - NAME((short)2, "name"), - FOLDER((short)3, "folder"), - SITE((short)4, "site"), - PASSWORD((short)5, "password"), +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class PackageData implements org.apache.thrift.TBase<PackageData, PackageData._Fields>, java.io.Serializable, Cloneable, Comparable<PackageData>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PackageData"); + + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField FOLDER_FIELD_DESC = new org.apache.thrift.protocol.TField("folder", org.apache.thrift.protocol.TType.STRING, (short) 3); + private static final org.apache.thrift.protocol.TField SITE_FIELD_DESC = new org.apache.thrift.protocol.TField("site", org.apache.thrift.protocol.TType.STRING, (short) 4); + private static final org.apache.thrift.protocol.TField PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short) 5); + private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short) 6); + private static final org.apache.thrift.protocol.TField ORDER_FIELD_DESC = new org.apache.thrift.protocol.TField("order", org.apache.thrift.protocol.TType.I16, (short) 7); + private static final org.apache.thrift.protocol.TField LINKSDONE_FIELD_DESC = new org.apache.thrift.protocol.TField("linksdone", org.apache.thrift.protocol.TType.I16, (short) 8); + private static final org.apache.thrift.protocol.TField SIZEDONE_FIELD_DESC = new org.apache.thrift.protocol.TField("sizedone", org.apache.thrift.protocol.TType.I64, (short) 9); + private static final org.apache.thrift.protocol.TField SIZETOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("sizetotal", org.apache.thrift.protocol.TType.I64, (short) 10); + private static final org.apache.thrift.protocol.TField LINKSTOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("linkstotal", org.apache.thrift.protocol.TType.I16, (short) 11); + private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short) 12); + private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short) 13); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new PackageDataStandardSchemeFactory()); + schemes.put(TupleScheme.class, new PackageDataTupleSchemeFactory()); + } + + public int pid; // required + public String name; // required + public String folder; // required + public String site; // required + public String password; // required /** - * + * * @see Destination */ - DEST((short)6, "dest"), - ORDER((short)7, "order"), - LINKSDONE((short)8, "linksdone"), - SIZEDONE((short)9, "sizedone"), - SIZETOTAL((short)10, "sizetotal"), - LINKSTOTAL((short)11, "linkstotal"), - LINKS((short)12, "links"), - FIDS((short)13, "fids"); + public Destination dest; // required + public short order; // required + public short linksdone; // optional + public long sizedone; // optional + public long sizetotal; // optional + public short linkstotal; // optional + public List<FileData> links; // optional + public List<Integer> fids; // optional + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(pid); + out.writeString(name); + out.writeString(folder); + out.writeString(site); + out.writeString(password); + out.writeInt(dest.getValue()); + out.writeInt(new Short(order).intValue()); + out.writeInt(new Short(linksdone).intValue()); + out.writeLong(sizedone); + out.writeLong(sizetotal); + out.writeInt(new Short(linkstotal).intValue()); + out.writeTypedList(links); + out.writeList(fids); + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + @Override + public int describeContents() { + return 0; + } + + public PackageData(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.pid = in.readInt(); + this.name = in.readString(); + this.folder = in.readString(); + this.site = in.readString(); + this.password = in.readString(); + this.dest = Destination.findByValue(in.readInt()); + this.order = (short) in.readInt(); + this.linksdone = (short) in.readInt(); + this.sizedone = in.readLong(); + this.sizetotal = in.readLong(); + this.linkstotal = (short) in.readInt(); + this.links = new ArrayList<FileData>(); + in.readTypedList(this.links, FileData.CREATOR); + this.fids = new ArrayList<Integer>(); + in.readList(this.fids, PackageData.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<PackageData> CREATOR = new android.os.Parcelable.Creator<PackageData>() { + @Override + public PackageData[] newArray(int size) { + return new PackageData[size]; + } + + @Override + public PackageData createFromParcel(android.os.Parcel in) { + return new PackageData(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"), + NAME((short) 2, "name"), + FOLDER((short) 3, "folder"), + SITE((short) 4, "site"), + PASSWORD((short) 5, "password"), + /** + * + * @see Destination + */ + DEST((short) 6, "dest"), + ORDER((short) 7, "order"), + LINKSDONE((short) 8, "linksdone"), + SIZEDONE((short) 9, "sizedone"), + SIZETOTAL((short) 10, "sizetotal"), + LINKSTOTAL((short) 11, "linkstotal"), + LINKS((short) 12, "links"), + FIDS((short) 13, "fids"); + + 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: // PID + return PID; + case 2: // NAME + return NAME; + case 3: // FOLDER + return FOLDER; + case 4: // SITE + return SITE; + case 5: // PASSWORD + return PASSWORD; + case 6: // DEST + return DEST; + case 7: // ORDER + return ORDER; + case 8: // LINKSDONE + return LINKSDONE; + case 9: // SIZEDONE + return SIZEDONE; + case 10: // SIZETOTAL + return SIZETOTAL; + case 11: // LINKSTOTAL + return LINKSTOTAL; + case 12: // LINKS + return LINKS; + case 13: // FIDS + return FIDS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private static final int __ORDER_ISSET_ID = 1; + private static final int __LINKSDONE_ISSET_ID = 2; + private static final int __SIZEDONE_ISSET_ID = 3; + private static final int __SIZETOTAL_ISSET_ID = 4; + private static final int __LINKSTOTAL_ISSET_ID = 5; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.LINKSDONE, _Fields.SIZEDONE, _Fields.SIZETOTAL, _Fields.LINKSTOTAL, _Fields.LINKS, _Fields.FIDS}; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.FOLDER, new org.apache.thrift.meta_data.FieldMetaData("folder", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.SITE, new org.apache.thrift.meta_data.FieldMetaData("site", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + tmpMap.put(_Fields.ORDER, new org.apache.thrift.meta_data.FieldMetaData("order", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.LINKSDONE, new org.apache.thrift.meta_data.FieldMetaData("linksdone", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.SIZEDONE, new org.apache.thrift.meta_data.FieldMetaData("sizedone", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.SIZETOTAL, new org.apache.thrift.meta_data.FieldMetaData("sizetotal", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.LINKSTOTAL, new org.apache.thrift.meta_data.FieldMetaData("linkstotal", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", 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, FileData.class)))); + tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32, "FileID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PackageData.class, metaDataMap); + } + + public PackageData() { + } + + public PackageData( + int pid, + String name, + String folder, + String site, + String password, + Destination dest, + short order) { + this(); + this.pid = pid; + setPidIsSet(true); + this.name = name; + this.folder = folder; + this.site = site; + this.password = password; + this.dest = dest; + this.order = order; + setOrderIsSet(true); } /** - * Find the _Fields constant that matches fieldId, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // PID - return PID; - case 2: // NAME - return NAME; - case 3: // FOLDER - return FOLDER; - case 4: // SITE - return SITE; - case 5: // PASSWORD - return PASSWORD; - case 6: // DEST - return DEST; - case 7: // ORDER - return ORDER; - case 8: // LINKSDONE - return LINKSDONE; - case 9: // SIZEDONE - return SIZEDONE; - case 10: // SIZETOTAL - return SIZETOTAL; - case 11: // LINKSTOTAL - return LINKSTOTAL; - case 12: // LINKS - return LINKS; - case 13: // FIDS - return FIDS; - default: - return null; - } + public PackageData(PackageData other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetFolder()) { + this.folder = other.folder; + } + if (other.isSetSite()) { + this.site = other.site; + } + if (other.isSetPassword()) { + this.password = other.password; + } + if (other.isSetDest()) { + this.dest = other.dest; + } + this.order = other.order; + this.linksdone = other.linksdone; + this.sizedone = other.sizedone; + this.sizetotal = other.sizetotal; + this.linkstotal = other.linkstotal; + if (other.isSetLinks()) { + List<FileData> __this__links = new ArrayList<FileData>(other.links.size()); + for (FileData other_element : other.links) { + __this__links.add(new FileData(other_element)); + } + this.links = __this__links; + } + if (other.isSetFids()) { + List<Integer> __this__fids = new ArrayList<Integer>(other.fids.size()); + for (Integer other_element : other.fids) { + __this__fids.add(other_element); + } + this.fids = __this__fids; + } + } + + public PackageData deepCopy() { + return new PackageData(this); + } + + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + this.name = null; + this.folder = null; + this.site = null; + this.password = null; + this.dest = null; + setOrderIsSet(false); + this.order = 0; + setLinksdoneIsSet(false); + this.linksdone = 0; + setSizedoneIsSet(false); + this.sizedone = 0; + setSizetotalIsSet(false); + this.sizetotal = 0; + setLinkstotalIsSet(false); + this.linkstotal = 0; + this.links = null; + this.fids = null; + } + + public int getPid() { + return this.pid; + } + + public PackageData setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } + + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } + + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } + + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } + + public String getName() { + return this.name; + } + + public PackageData setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getFolder() { + return this.folder; + } + + public PackageData setFolder(String folder) { + this.folder = folder; + return this; + } + + public void unsetFolder() { + this.folder = null; + } + + /** Returns true if field folder is set (has been assigned a value) and false otherwise */ + public boolean isSetFolder() { + return this.folder != null; + } + + public void setFolderIsSet(boolean value) { + if (!value) { + this.folder = null; + } + } + + public String getSite() { + return this.site; + } + + public PackageData setSite(String site) { + this.site = site; + return this; + } + + public void unsetSite() { + this.site = null; + } + + /** Returns true if field site is set (has been assigned a value) and false otherwise */ + public boolean isSetSite() { + return this.site != null; + } + + public void setSiteIsSet(boolean value) { + if (!value) { + this.site = null; + } + } + + public String getPassword() { + return this.password; + } + + public PackageData setPassword(String password) { + this.password = password; + return this; + } + + public void unsetPassword() { + this.password = null; + } + + /** Returns true if field password is set (has been assigned a value) and false otherwise */ + public boolean isSetPassword() { + return this.password != null; + } + + public void setPasswordIsSet(boolean value) { + if (!value) { + this.password = null; + } } /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. + * + * @see Destination */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; + public Destination getDest() { + return this.dest; } /** - * Find the _Fields constant that matches name, or null if its not found. + * + * @see Destination */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private static final int __ORDER_ISSET_ID = 1; - private static final int __LINKSDONE_ISSET_ID = 2; - private static final int __SIZEDONE_ISSET_ID = 3; - private static final int __SIZETOTAL_ISSET_ID = 4; - private static final int __LINKSTOTAL_ISSET_ID = 5; - private BitSet __isset_bit_vector = new BitSet(6); - private _Fields optionals[] = {_Fields.LINKSDONE,_Fields.SIZEDONE,_Fields.SIZETOTAL,_Fields.LINKSTOTAL,_Fields.LINKS,_Fields.FIDS}; - 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.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.FOLDER, new org.apache.thrift.meta_data.FieldMetaData("folder", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.SITE, new org.apache.thrift.meta_data.FieldMetaData("site", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - tmpMap.put(_Fields.ORDER, new org.apache.thrift.meta_data.FieldMetaData("order", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.LINKSDONE, new org.apache.thrift.meta_data.FieldMetaData("linksdone", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.SIZEDONE, new org.apache.thrift.meta_data.FieldMetaData("sizedone", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.SIZETOTAL, new org.apache.thrift.meta_data.FieldMetaData("sizetotal", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.LINKSTOTAL, new org.apache.thrift.meta_data.FieldMetaData("linkstotal", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", 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, FileData.class)))); - tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32 , "FileID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PackageData.class, metaDataMap); - } - - public PackageData() { - } - - public PackageData( - int pid, - String name, - String folder, - String site, - String password, - Destination dest, - short order) - { - this(); - this.pid = pid; - setPidIsSet(true); - this.name = name; - this.folder = folder; - this.site = site; - this.password = password; - this.dest = dest; - this.order = order; - setOrderIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public PackageData(PackageData other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetFolder()) { - this.folder = other.folder; - } - if (other.isSetSite()) { - this.site = other.site; - } - if (other.isSetPassword()) { - this.password = other.password; - } - if (other.isSetDest()) { - this.dest = other.dest; - } - this.order = other.order; - this.linksdone = other.linksdone; - this.sizedone = other.sizedone; - this.sizetotal = other.sizetotal; - this.linkstotal = other.linkstotal; - if (other.isSetLinks()) { - List<FileData> __this__links = new ArrayList<FileData>(); - for (FileData other_element : other.links) { - __this__links.add(new FileData(other_element)); - } - this.links = __this__links; - } - if (other.isSetFids()) { - List<Integer> __this__fids = new ArrayList<Integer>(); - for (Integer other_element : other.fids) { - __this__fids.add(other_element); - } - this.fids = __this__fids; - } - } - - public PackageData deepCopy() { - return new PackageData(this); - } - - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - this.name = null; - this.folder = null; - this.site = null; - this.password = null; - this.dest = null; - setOrderIsSet(false); - this.order = 0; - setLinksdoneIsSet(false); - this.linksdone = 0; - setSizedoneIsSet(false); - this.sizedone = 0; - setSizetotalIsSet(false); - this.sizetotal = 0; - setLinkstotalIsSet(false); - this.linkstotal = 0; - this.links = null; - this.fids = null; - } - - public int getPid() { - return this.pid; - } - - public PackageData setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } - - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } - - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } - - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } - - public String getName() { - return this.name; - } - - public PackageData setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getFolder() { - return this.folder; - } - - public PackageData setFolder(String folder) { - this.folder = folder; - return this; - } - - public void unsetFolder() { - this.folder = null; - } - - /** Returns true if field folder is set (has been assigned a value) and false otherwise */ - public boolean isSetFolder() { - return this.folder != null; - } - - public void setFolderIsSet(boolean value) { - if (!value) { - this.folder = null; - } - } - - public String getSite() { - return this.site; - } - - public PackageData setSite(String site) { - this.site = site; - return this; - } - - public void unsetSite() { - this.site = null; - } - - /** Returns true if field site is set (has been assigned a value) and false otherwise */ - public boolean isSetSite() { - return this.site != null; - } - - public void setSiteIsSet(boolean value) { - if (!value) { - this.site = null; - } - } - - public String getPassword() { - return this.password; - } - - public PackageData setPassword(String password) { - this.password = password; - return this; - } - - public void unsetPassword() { - this.password = null; - } - - /** Returns true if field password is set (has been assigned a value) and false otherwise */ - public boolean isSetPassword() { - return this.password != null; - } - - public void setPasswordIsSet(boolean value) { - if (!value) { - this.password = null; - } - } - - /** - * - * @see Destination - */ - public Destination getDest() { - return this.dest; - } - - /** - * - * @see Destination - */ - public PackageData setDest(Destination dest) { - this.dest = dest; - return this; - } - - public void unsetDest() { - this.dest = null; - } - - /** Returns true if field dest is set (has been assigned a value) and false otherwise */ - public boolean isSetDest() { - return this.dest != null; - } - - public void setDestIsSet(boolean value) { - if (!value) { - this.dest = null; - } - } - - public short getOrder() { - return this.order; - } - - public PackageData setOrder(short order) { - this.order = order; - setOrderIsSet(true); - return this; - } - - public void unsetOrder() { - __isset_bit_vector.clear(__ORDER_ISSET_ID); - } - - /** Returns true if field order is set (has been assigned a value) and false otherwise */ - public boolean isSetOrder() { - return __isset_bit_vector.get(__ORDER_ISSET_ID); - } - - public void setOrderIsSet(boolean value) { - __isset_bit_vector.set(__ORDER_ISSET_ID, value); - } - - public short getLinksdone() { - return this.linksdone; - } - - public PackageData setLinksdone(short linksdone) { - this.linksdone = linksdone; - setLinksdoneIsSet(true); - return this; - } - - public void unsetLinksdone() { - __isset_bit_vector.clear(__LINKSDONE_ISSET_ID); - } - - /** Returns true if field linksdone is set (has been assigned a value) and false otherwise */ - public boolean isSetLinksdone() { - return __isset_bit_vector.get(__LINKSDONE_ISSET_ID); - } - - public void setLinksdoneIsSet(boolean value) { - __isset_bit_vector.set(__LINKSDONE_ISSET_ID, value); - } - - public long getSizedone() { - return this.sizedone; - } - - public PackageData setSizedone(long sizedone) { - this.sizedone = sizedone; - setSizedoneIsSet(true); - return this; - } - - public void unsetSizedone() { - __isset_bit_vector.clear(__SIZEDONE_ISSET_ID); - } - - /** Returns true if field sizedone is set (has been assigned a value) and false otherwise */ - public boolean isSetSizedone() { - return __isset_bit_vector.get(__SIZEDONE_ISSET_ID); - } - - public void setSizedoneIsSet(boolean value) { - __isset_bit_vector.set(__SIZEDONE_ISSET_ID, value); - } - - public long getSizetotal() { - return this.sizetotal; - } - - public PackageData setSizetotal(long sizetotal) { - this.sizetotal = sizetotal; - setSizetotalIsSet(true); - return this; - } - - public void unsetSizetotal() { - __isset_bit_vector.clear(__SIZETOTAL_ISSET_ID); - } - - /** Returns true if field sizetotal is set (has been assigned a value) and false otherwise */ - public boolean isSetSizetotal() { - return __isset_bit_vector.get(__SIZETOTAL_ISSET_ID); - } - - public void setSizetotalIsSet(boolean value) { - __isset_bit_vector.set(__SIZETOTAL_ISSET_ID, value); - } - - public short getLinkstotal() { - return this.linkstotal; - } - - public PackageData setLinkstotal(short linkstotal) { - this.linkstotal = linkstotal; - setLinkstotalIsSet(true); - return this; - } - - public void unsetLinkstotal() { - __isset_bit_vector.clear(__LINKSTOTAL_ISSET_ID); - } - - /** Returns true if field linkstotal is set (has been assigned a value) and false otherwise */ - public boolean isSetLinkstotal() { - return __isset_bit_vector.get(__LINKSTOTAL_ISSET_ID); - } - - public void setLinkstotalIsSet(boolean value) { - __isset_bit_vector.set(__LINKSTOTAL_ISSET_ID, value); - } - - public int getLinksSize() { - return (this.links == null) ? 0 : this.links.size(); - } - - public java.util.Iterator<FileData> getLinksIterator() { - return (this.links == null) ? null : this.links.iterator(); - } - - public void addToLinks(FileData elem) { - if (this.links == null) { - this.links = new ArrayList<FileData>(); - } - this.links.add(elem); - } - - public List<FileData> getLinks() { - return this.links; - } - - public PackageData setLinks(List<FileData> links) { - this.links = links; - return this; - } - - public void unsetLinks() { - this.links = null; - } - - /** Returns true if field links is set (has been assigned a value) and false otherwise */ - public boolean isSetLinks() { - return this.links != null; - } - - public void setLinksIsSet(boolean value) { - if (!value) { - this.links = null; - } - } - - public int getFidsSize() { - return (this.fids == null) ? 0 : this.fids.size(); - } - - public java.util.Iterator<Integer> getFidsIterator() { - return (this.fids == null) ? null : this.fids.iterator(); - } - - public void addToFids(int elem) { - if (this.fids == null) { - this.fids = new ArrayList<Integer>(); - } - this.fids.add(elem); - } - - public List<Integer> getFids() { - return this.fids; - } - - public PackageData setFids(List<Integer> fids) { - this.fids = fids; - return this; - } - - public void unsetFids() { - this.fids = null; - } - - /** Returns true if field fids is set (has been assigned a value) and false otherwise */ - public boolean isSetFids() { - return this.fids != null; - } - - public void setFidsIsSet(boolean value) { - if (!value) { - this.fids = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); - } - break; - - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case FOLDER: - if (value == null) { - unsetFolder(); - } else { - setFolder((String)value); - } - break; - - case SITE: - if (value == null) { - unsetSite(); - } else { - setSite((String)value); - } - break; - - case PASSWORD: - if (value == null) { - unsetPassword(); - } else { - setPassword((String)value); - } - break; - - case DEST: - if (value == null) { - unsetDest(); - } else { - setDest((Destination)value); - } - break; - - case ORDER: - if (value == null) { - unsetOrder(); - } else { - setOrder((Short)value); - } - break; - - case LINKSDONE: - if (value == null) { - unsetLinksdone(); - } else { - setLinksdone((Short)value); - } - break; - - case SIZEDONE: - if (value == null) { - unsetSizedone(); - } else { - setSizedone((Long)value); - } - break; - - case SIZETOTAL: - if (value == null) { - unsetSizetotal(); - } else { - setSizetotal((Long)value); - } - break; - - case LINKSTOTAL: - if (value == null) { - unsetLinkstotal(); - } else { - setLinkstotal((Short)value); - } - break; - - case LINKS: - if (value == null) { - unsetLinks(); - } else { - setLinks((List<FileData>)value); - } - break; - - case FIDS: - if (value == null) { - unsetFids(); - } else { - setFids((List<Integer>)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); - - case NAME: - return getName(); - - case FOLDER: - return getFolder(); - - case SITE: - return getSite(); - - case PASSWORD: - return getPassword(); - - case DEST: - return getDest(); - - case ORDER: - return Short.valueOf(getOrder()); - - case LINKSDONE: - return Short.valueOf(getLinksdone()); - - case SIZEDONE: - return Long.valueOf(getSizedone()); - - case SIZETOTAL: - return Long.valueOf(getSizetotal()); - - case LINKSTOTAL: - return Short.valueOf(getLinkstotal()); - - case LINKS: - return getLinks(); - - case FIDS: - return getFids(); - - } - 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 PID: - return isSetPid(); - case NAME: - return isSetName(); - case FOLDER: - return isSetFolder(); - case SITE: - return isSetSite(); - case PASSWORD: - return isSetPassword(); - case DEST: - return isSetDest(); - case ORDER: - return isSetOrder(); - case LINKSDONE: - return isSetLinksdone(); - case SIZEDONE: - return isSetSizedone(); - case SIZETOTAL: - return isSetSizetotal(); - case LINKSTOTAL: - return isSetLinkstotal(); - case LINKS: - return isSetLinks(); - case FIDS: - return isSetFids(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof PackageData) - return this.equals((PackageData)that); - return false; - } - - public boolean equals(PackageData that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; + public PackageData setDest(Destination dest) { + this.dest = dest; + return this; } - 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; + public void unsetDest() { + this.dest = null; } - boolean this_present_folder = true && this.isSetFolder(); - boolean that_present_folder = true && that.isSetFolder(); - if (this_present_folder || that_present_folder) { - if (!(this_present_folder && that_present_folder)) - return false; - if (!this.folder.equals(that.folder)) - return false; + /** Returns true if field dest is set (has been assigned a value) and false otherwise */ + public boolean isSetDest() { + return this.dest != null; } - boolean this_present_site = true && this.isSetSite(); - boolean that_present_site = true && that.isSetSite(); - if (this_present_site || that_present_site) { - if (!(this_present_site && that_present_site)) - return false; - if (!this.site.equals(that.site)) - return false; + public void setDestIsSet(boolean value) { + if (!value) { + this.dest = null; + } } - boolean this_present_password = true && this.isSetPassword(); - boolean that_present_password = true && that.isSetPassword(); - if (this_present_password || that_present_password) { - if (!(this_present_password && that_present_password)) - return false; - if (!this.password.equals(that.password)) - return false; + public short getOrder() { + return this.order; } - boolean this_present_dest = true && this.isSetDest(); - boolean that_present_dest = true && that.isSetDest(); - if (this_present_dest || that_present_dest) { - if (!(this_present_dest && that_present_dest)) - return false; - if (!this.dest.equals(that.dest)) - return false; + public PackageData setOrder(short order) { + this.order = order; + setOrderIsSet(true); + return this; } - boolean this_present_order = true; - boolean that_present_order = true; - if (this_present_order || that_present_order) { - if (!(this_present_order && that_present_order)) - return false; - if (this.order != that.order) - return false; + public void unsetOrder() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ORDER_ISSET_ID); } - boolean this_present_linksdone = true && this.isSetLinksdone(); - boolean that_present_linksdone = true && that.isSetLinksdone(); - if (this_present_linksdone || that_present_linksdone) { - if (!(this_present_linksdone && that_present_linksdone)) - return false; - if (this.linksdone != that.linksdone) - return false; + /** Returns true if field order is set (has been assigned a value) and false otherwise */ + public boolean isSetOrder() { + return EncodingUtils.testBit(__isset_bitfield, __ORDER_ISSET_ID); } - boolean this_present_sizedone = true && this.isSetSizedone(); - boolean that_present_sizedone = true && that.isSetSizedone(); - if (this_present_sizedone || that_present_sizedone) { - if (!(this_present_sizedone && that_present_sizedone)) - return false; - if (this.sizedone != that.sizedone) - return false; + public void setOrderIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ORDER_ISSET_ID, value); } - boolean this_present_sizetotal = true && this.isSetSizetotal(); - boolean that_present_sizetotal = true && that.isSetSizetotal(); - if (this_present_sizetotal || that_present_sizetotal) { - if (!(this_present_sizetotal && that_present_sizetotal)) - return false; - if (this.sizetotal != that.sizetotal) - return false; + public short getLinksdone() { + return this.linksdone; } - boolean this_present_linkstotal = true && this.isSetLinkstotal(); - boolean that_present_linkstotal = true && that.isSetLinkstotal(); - if (this_present_linkstotal || that_present_linkstotal) { - if (!(this_present_linkstotal && that_present_linkstotal)) - return false; - if (this.linkstotal != that.linkstotal) - return false; + public PackageData setLinksdone(short linksdone) { + this.linksdone = linksdone; + setLinksdoneIsSet(true); + return this; } - boolean this_present_links = true && this.isSetLinks(); - boolean that_present_links = true && that.isSetLinks(); - if (this_present_links || that_present_links) { - if (!(this_present_links && that_present_links)) - return false; - if (!this.links.equals(that.links)) - return false; + public void unsetLinksdone() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LINKSDONE_ISSET_ID); } - boolean this_present_fids = true && this.isSetFids(); - boolean that_present_fids = true && that.isSetFids(); - if (this_present_fids || that_present_fids) { - if (!(this_present_fids && that_present_fids)) - return false; - if (!this.fids.equals(that.fids)) - return false; + /** Returns true if field linksdone is set (has been assigned a value) and false otherwise */ + public boolean isSetLinksdone() { + return EncodingUtils.testBit(__isset_bitfield, __LINKSDONE_ISSET_ID); } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(PackageData other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - PackageData typedOther = (PackageData)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFolder()).compareTo(typedOther.isSetFolder()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFolder()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.folder, typedOther.folder); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSite()).compareTo(typedOther.isSetSite()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSite()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.site, typedOther.site); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPassword()).compareTo(typedOther.isSetPassword()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPassword()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, typedOther.password); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDest()).compareTo(typedOther.isSetDest()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDest()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, typedOther.dest); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOrder()).compareTo(typedOther.isSetOrder()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOrder()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.order, typedOther.order); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLinksdone()).compareTo(typedOther.isSetLinksdone()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinksdone()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.linksdone, typedOther.linksdone); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSizedone()).compareTo(typedOther.isSetSizedone()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSizedone()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sizedone, typedOther.sizedone); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSizetotal()).compareTo(typedOther.isSetSizetotal()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSizetotal()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sizetotal, typedOther.sizetotal); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLinkstotal()).compareTo(typedOther.isSetLinkstotal()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinkstotal()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.linkstotal, typedOther.linkstotal); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLinks()).compareTo(typedOther.isSetLinks()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinks()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, typedOther.links); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFids()).compareTo(typedOther.isSetFids()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFids()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, typedOther.fids); - 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("PackageData("); - boolean first = true; - - sb.append("pid:"); - sb.append(this.pid); - first = false; - if (!first) sb.append(", "); - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("folder:"); - if (this.folder == null) { - sb.append("null"); - } else { - sb.append(this.folder); - } - first = false; - if (!first) sb.append(", "); - sb.append("site:"); - if (this.site == null) { - sb.append("null"); - } else { - sb.append(this.site); - } - first = false; - if (!first) sb.append(", "); - sb.append("password:"); - if (this.password == null) { - sb.append("null"); - } else { - sb.append(this.password); - } - first = false; - if (!first) sb.append(", "); - sb.append("dest:"); - if (this.dest == null) { - sb.append("null"); - } else { - sb.append(this.dest); - } - first = false; - if (!first) sb.append(", "); - sb.append("order:"); - sb.append(this.order); - first = false; - if (isSetLinksdone()) { - if (!first) sb.append(", "); - sb.append("linksdone:"); - sb.append(this.linksdone); - first = false; - } - if (isSetSizedone()) { - if (!first) sb.append(", "); - sb.append("sizedone:"); - sb.append(this.sizedone); - first = false; - } - if (isSetSizetotal()) { - if (!first) sb.append(", "); - sb.append("sizetotal:"); - sb.append(this.sizetotal); - first = false; - } - if (isSetLinkstotal()) { - if (!first) sb.append(", "); - sb.append("linkstotal:"); - sb.append(this.linkstotal); - first = false; - } - if (isSetLinks()) { - if (!first) sb.append(", "); - sb.append("links:"); - if (this.links == null) { - sb.append("null"); - } else { - sb.append(this.links); - } - first = false; - } - if (isSetFids()) { - if (!first) sb.append(", "); - sb.append("fids:"); - if (this.fids == null) { - sb.append("null"); - } else { - sb.append(this.fids); - } - first = false; - } - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class PackageDataStandardSchemeFactory implements SchemeFactory { - public PackageDataStandardScheme getScheme() { - return new PackageDataStandardScheme(); - } - } - - private static class PackageDataStandardScheme extends StandardScheme<PackageData> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, PackageData 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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // 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 3: // FOLDER - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.folder = iprot.readString(); - struct.setFolderIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 4: // SITE - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.site = iprot.readString(); - struct.setSiteIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 5: // PASSWORD - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 6: // DEST - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 7: // ORDER - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.order = iprot.readI16(); - struct.setOrderIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 8: // LINKSDONE - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.linksdone = iprot.readI16(); - struct.setLinksdoneIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 9: // SIZEDONE - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.sizedone = iprot.readI64(); - struct.setSizedoneIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 10: // SIZETOTAL - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.sizetotal = iprot.readI64(); - struct.setSizetotalIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 11: // LINKSTOTAL - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.linkstotal = iprot.readI16(); - struct.setLinkstotalIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 12: // LINKS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list8 = iprot.readListBegin(); - struct.links = new ArrayList<FileData>(_list8.size); - for (int _i9 = 0; _i9 < _list8.size; ++_i9) - { - FileData _elem10; // required - _elem10 = new FileData(); - _elem10.read(iprot); - struct.links.add(_elem10); + public void setLinksdoneIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LINKSDONE_ISSET_ID, value); + } + + public long getSizedone() { + return this.sizedone; + } + + public PackageData setSizedone(long sizedone) { + this.sizedone = sizedone; + setSizedoneIsSet(true); + return this; + } + + public void unsetSizedone() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SIZEDONE_ISSET_ID); + } + + /** Returns true if field sizedone is set (has been assigned a value) and false otherwise */ + public boolean isSetSizedone() { + return EncodingUtils.testBit(__isset_bitfield, __SIZEDONE_ISSET_ID); + } + + public void setSizedoneIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SIZEDONE_ISSET_ID, value); + } + + public long getSizetotal() { + return this.sizetotal; + } + + public PackageData setSizetotal(long sizetotal) { + this.sizetotal = sizetotal; + setSizetotalIsSet(true); + return this; + } + + public void unsetSizetotal() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SIZETOTAL_ISSET_ID); + } + + /** Returns true if field sizetotal is set (has been assigned a value) and false otherwise */ + public boolean isSetSizetotal() { + return EncodingUtils.testBit(__isset_bitfield, __SIZETOTAL_ISSET_ID); + } + + public void setSizetotalIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SIZETOTAL_ISSET_ID, value); + } + + public short getLinkstotal() { + return this.linkstotal; + } + + public PackageData setLinkstotal(short linkstotal) { + this.linkstotal = linkstotal; + setLinkstotalIsSet(true); + return this; + } + + public void unsetLinkstotal() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LINKSTOTAL_ISSET_ID); + } + + /** Returns true if field linkstotal is set (has been assigned a value) and false otherwise */ + public boolean isSetLinkstotal() { + return EncodingUtils.testBit(__isset_bitfield, __LINKSTOTAL_ISSET_ID); + } + + public void setLinkstotalIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LINKSTOTAL_ISSET_ID, value); + } + + public int getLinksSize() { + return (this.links == null) ? 0 : this.links.size(); + } + + public java.util.Iterator<FileData> getLinksIterator() { + return (this.links == null) ? null : this.links.iterator(); + } + + public void addToLinks(FileData elem) { + if (this.links == null) { + this.links = new ArrayList<FileData>(); + } + this.links.add(elem); + } + + public List<FileData> getLinks() { + return this.links; + } + + public PackageData setLinks(List<FileData> links) { + this.links = links; + return this; + } + + public void unsetLinks() { + this.links = null; + } + + /** Returns true if field links is set (has been assigned a value) and false otherwise */ + public boolean isSetLinks() { + return this.links != null; + } + + public void setLinksIsSet(boolean value) { + if (!value) { + this.links = null; + } + } + + public int getFidsSize() { + return (this.fids == null) ? 0 : this.fids.size(); + } + + public java.util.Iterator<Integer> getFidsIterator() { + return (this.fids == null) ? null : this.fids.iterator(); + } + + public void addToFids(int elem) { + if (this.fids == null) { + this.fids = new ArrayList<Integer>(); + } + this.fids.add(elem); + } + + public List<Integer> getFids() { + return this.fids; + } + + public PackageData setFids(List<Integer> fids) { + this.fids = fids; + return this; + } + + public void unsetFids() { + this.fids = null; + } + + /** Returns true if field fids is set (has been assigned a value) and false otherwise */ + public boolean isSetFids() { + return this.fids != null; + } + + public void setFidsIsSet(boolean value) { + if (!value) { + this.fids = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); } - iprot.readListEnd(); - } - struct.setLinksIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 13: // FIDS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list11 = iprot.readListBegin(); - struct.fids = new ArrayList<Integer>(_list11.size); - for (int _i12 = 0; _i12 < _list11.size; ++_i12) - { - int _elem13; // required - _elem13 = iprot.readI32(); - struct.fids.add(_elem13); + break; + + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case FOLDER: + if (value == null) { + unsetFolder(); + } else { + setFolder((String) value); + } + break; + + case SITE: + if (value == null) { + unsetSite(); + } else { + setSite((String) value); } - iprot.readListEnd(); - } - struct.setFidsIsSet(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, PackageData struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - if (struct.name != null) { - oprot.writeFieldBegin(NAME_FIELD_DESC); - oprot.writeString(struct.name); - oprot.writeFieldEnd(); - } - if (struct.folder != null) { - oprot.writeFieldBegin(FOLDER_FIELD_DESC); - oprot.writeString(struct.folder); - oprot.writeFieldEnd(); - } - if (struct.site != null) { - oprot.writeFieldBegin(SITE_FIELD_DESC); - oprot.writeString(struct.site); - oprot.writeFieldEnd(); - } - if (struct.password != null) { - oprot.writeFieldBegin(PASSWORD_FIELD_DESC); - oprot.writeString(struct.password); - oprot.writeFieldEnd(); - } - if (struct.dest != null) { - oprot.writeFieldBegin(DEST_FIELD_DESC); - oprot.writeI32(struct.dest.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(ORDER_FIELD_DESC); - oprot.writeI16(struct.order); - oprot.writeFieldEnd(); - if (struct.isSetLinksdone()) { - oprot.writeFieldBegin(LINKSDONE_FIELD_DESC); - oprot.writeI16(struct.linksdone); - oprot.writeFieldEnd(); - } - if (struct.isSetSizedone()) { - oprot.writeFieldBegin(SIZEDONE_FIELD_DESC); - oprot.writeI64(struct.sizedone); - oprot.writeFieldEnd(); - } - if (struct.isSetSizetotal()) { - oprot.writeFieldBegin(SIZETOTAL_FIELD_DESC); - oprot.writeI64(struct.sizetotal); - oprot.writeFieldEnd(); - } - if (struct.isSetLinkstotal()) { - oprot.writeFieldBegin(LINKSTOTAL_FIELD_DESC); - oprot.writeI16(struct.linkstotal); - oprot.writeFieldEnd(); - } - if (struct.links != null) { - if (struct.isSetLinks()) { - oprot.writeFieldBegin(LINKS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.links.size())); - for (FileData _iter14 : struct.links) - { - _iter14.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - } - if (struct.fids != null) { - if (struct.isSetFids()) { - oprot.writeFieldBegin(FIDS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); - for (int _iter15 : struct.fids) - { - oprot.writeI32(_iter15); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class PackageDataTupleSchemeFactory implements SchemeFactory { - public PackageDataTupleScheme getScheme() { - return new PackageDataTupleScheme(); - } - } - - private static class PackageDataTupleScheme extends TupleScheme<PackageData> { + break; + + case PASSWORD: + if (value == null) { + unsetPassword(); + } else { + setPassword((String) value); + } + break; + + case DEST: + if (value == null) { + unsetDest(); + } else { + setDest((Destination) value); + } + break; + + case ORDER: + if (value == null) { + unsetOrder(); + } else { + setOrder((Short) value); + } + break; + + case LINKSDONE: + if (value == null) { + unsetLinksdone(); + } else { + setLinksdone((Short) value); + } + break; + + case SIZEDONE: + if (value == null) { + unsetSizedone(); + } else { + setSizedone((Long) value); + } + break; + + case SIZETOTAL: + if (value == null) { + unsetSizetotal(); + } else { + setSizetotal((Long) value); + } + break; + + case LINKSTOTAL: + if (value == null) { + unsetLinkstotal(); + } else { + setLinkstotal((Short) value); + } + break; + + case LINKS: + if (value == null) { + unsetLinks(); + } else { + setLinks((List<FileData>) value); + } + break; + + case FIDS: + if (value == null) { + unsetFids(); + } else { + setFids((List<Integer>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); + + case NAME: + return getName(); + + case FOLDER: + return getFolder(); + + case SITE: + return getSite(); + + case PASSWORD: + return getPassword(); + + case DEST: + return getDest(); + + case ORDER: + return getOrder(); + + case LINKSDONE: + return getLinksdone(); + + case SIZEDONE: + return getSizedone(); + + case SIZETOTAL: + return getSizetotal(); + + case LINKSTOTAL: + return getLinkstotal(); + + case LINKS: + return getLinks(); + + case FIDS: + return getFids(); + + } + 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 PID: + return isSetPid(); + case NAME: + return isSetName(); + case FOLDER: + return isSetFolder(); + case SITE: + return isSetSite(); + case PASSWORD: + return isSetPassword(); + case DEST: + return isSetDest(); + case ORDER: + return isSetOrder(); + case LINKSDONE: + return isSetLinksdone(); + case SIZEDONE: + return isSetSizedone(); + case SIZETOTAL: + return isSetSizetotal(); + case LINKSTOTAL: + return isSetLinkstotal(); + case LINKS: + return isSetLinks(); + case FIDS: + return isSetFids(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof PackageData) + return this.equals((PackageData) that); + return false; + } + + public boolean equals(PackageData that) { + if (that == null) + return false; + + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + 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_folder = true && this.isSetFolder(); + boolean that_present_folder = true && that.isSetFolder(); + if (this_present_folder || that_present_folder) { + if (!(this_present_folder && that_present_folder)) + return false; + if (!this.folder.equals(that.folder)) + return false; + } + + boolean this_present_site = true && this.isSetSite(); + boolean that_present_site = true && that.isSetSite(); + if (this_present_site || that_present_site) { + if (!(this_present_site && that_present_site)) + return false; + if (!this.site.equals(that.site)) + return false; + } + + boolean this_present_password = true && this.isSetPassword(); + boolean that_present_password = true && that.isSetPassword(); + if (this_present_password || that_present_password) { + if (!(this_present_password && that_present_password)) + return false; + if (!this.password.equals(that.password)) + return false; + } + + boolean this_present_dest = true && this.isSetDest(); + boolean that_present_dest = true && that.isSetDest(); + if (this_present_dest || that_present_dest) { + if (!(this_present_dest && that_present_dest)) + return false; + if (!this.dest.equals(that.dest)) + return false; + } + + boolean this_present_order = true; + boolean that_present_order = true; + if (this_present_order || that_present_order) { + if (!(this_present_order && that_present_order)) + return false; + if (this.order != that.order) + return false; + } + + boolean this_present_linksdone = true && this.isSetLinksdone(); + boolean that_present_linksdone = true && that.isSetLinksdone(); + if (this_present_linksdone || that_present_linksdone) { + if (!(this_present_linksdone && that_present_linksdone)) + return false; + if (this.linksdone != that.linksdone) + return false; + } + + boolean this_present_sizedone = true && this.isSetSizedone(); + boolean that_present_sizedone = true && that.isSetSizedone(); + if (this_present_sizedone || that_present_sizedone) { + if (!(this_present_sizedone && that_present_sizedone)) + return false; + if (this.sizedone != that.sizedone) + return false; + } + + boolean this_present_sizetotal = true && this.isSetSizetotal(); + boolean that_present_sizetotal = true && that.isSetSizetotal(); + if (this_present_sizetotal || that_present_sizetotal) { + if (!(this_present_sizetotal && that_present_sizetotal)) + return false; + if (this.sizetotal != that.sizetotal) + return false; + } + + boolean this_present_linkstotal = true && this.isSetLinkstotal(); + boolean that_present_linkstotal = true && that.isSetLinkstotal(); + if (this_present_linkstotal || that_present_linkstotal) { + if (!(this_present_linkstotal && that_present_linkstotal)) + return false; + if (this.linkstotal != that.linkstotal) + return false; + } + + boolean this_present_links = true && this.isSetLinks(); + boolean that_present_links = true && that.isSetLinks(); + if (this_present_links || that_present_links) { + if (!(this_present_links && that_present_links)) + return false; + if (!this.links.equals(that.links)) + return false; + } + + boolean this_present_fids = true && this.isSetFids(); + boolean that_present_fids = true && that.isSetFids(); + if (this_present_fids || that_present_fids) { + if (!(this_present_fids && that_present_fids)) + return false; + if (!this.fids.equals(that.fids)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); + + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); + + boolean present_folder = true && (isSetFolder()); + list.add(present_folder); + if (present_folder) + list.add(folder); + + boolean present_site = true && (isSetSite()); + list.add(present_site); + if (present_site) + list.add(site); + + boolean present_password = true && (isSetPassword()); + list.add(present_password); + if (present_password) + list.add(password); + + boolean present_dest = true && (isSetDest()); + list.add(present_dest); + if (present_dest) + list.add(dest.getValue()); + + boolean present_order = true; + list.add(present_order); + if (present_order) + list.add(order); + + boolean present_linksdone = true && (isSetLinksdone()); + list.add(present_linksdone); + if (present_linksdone) + list.add(linksdone); + + boolean present_sizedone = true && (isSetSizedone()); + list.add(present_sizedone); + if (present_sizedone) + list.add(sizedone); + + boolean present_sizetotal = true && (isSetSizetotal()); + list.add(present_sizetotal); + if (present_sizetotal) + list.add(sizetotal); + + boolean present_linkstotal = true && (isSetLinkstotal()); + list.add(present_linkstotal); + if (present_linkstotal) + list.add(linkstotal); + + boolean present_links = true && (isSetLinks()); + list.add(present_links); + if (present_links) + list.add(links); + + boolean present_fids = true && (isSetFids()); + list.add(present_fids); + if (present_fids) + list.add(fids); + + return list.hashCode(); + } @Override - public void write(org.apache.thrift.protocol.TProtocol prot, PackageData struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - if (struct.isSetName()) { - optionals.set(1); - } - if (struct.isSetFolder()) { - optionals.set(2); - } - if (struct.isSetSite()) { - optionals.set(3); - } - if (struct.isSetPassword()) { - optionals.set(4); - } - if (struct.isSetDest()) { - optionals.set(5); - } - if (struct.isSetOrder()) { - optionals.set(6); - } - if (struct.isSetLinksdone()) { - optionals.set(7); - } - if (struct.isSetSizedone()) { - optionals.set(8); - } - if (struct.isSetSizetotal()) { - optionals.set(9); - } - if (struct.isSetLinkstotal()) { - optionals.set(10); - } - if (struct.isSetLinks()) { - optionals.set(11); - } - if (struct.isSetFids()) { - optionals.set(12); - } - oprot.writeBitSet(optionals, 13); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetFolder()) { - oprot.writeString(struct.folder); - } - if (struct.isSetSite()) { - oprot.writeString(struct.site); - } - if (struct.isSetPassword()) { - oprot.writeString(struct.password); - } - if (struct.isSetDest()) { - oprot.writeI32(struct.dest.getValue()); - } - if (struct.isSetOrder()) { - oprot.writeI16(struct.order); - } - if (struct.isSetLinksdone()) { - oprot.writeI16(struct.linksdone); - } - if (struct.isSetSizedone()) { - oprot.writeI64(struct.sizedone); - } - if (struct.isSetSizetotal()) { - oprot.writeI64(struct.sizetotal); - } - if (struct.isSetLinkstotal()) { - oprot.writeI16(struct.linkstotal); - } - if (struct.isSetLinks()) { - { - oprot.writeI32(struct.links.size()); - for (FileData _iter16 : struct.links) - { - _iter16.write(oprot); - } - } - } - if (struct.isSetFids()) { - { - oprot.writeI32(struct.fids.size()); - for (int _iter17 : struct.fids) - { - oprot.writeI32(_iter17); - } - } - } + public int compareTo(PackageData other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + 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(isSetFolder()).compareTo(other.isSetFolder()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFolder()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.folder, other.folder); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSite()).compareTo(other.isSetSite()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSite()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.site, other.site); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPassword()).compareTo(other.isSetPassword()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPassword()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, other.password); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDest()).compareTo(other.isSetDest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, other.dest); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOrder()).compareTo(other.isSetOrder()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOrder()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.order, other.order); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLinksdone()).compareTo(other.isSetLinksdone()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinksdone()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.linksdone, other.linksdone); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSizedone()).compareTo(other.isSetSizedone()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSizedone()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sizedone, other.sizedone); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSizetotal()).compareTo(other.isSetSizetotal()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSizetotal()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.sizetotal, other.sizetotal); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLinkstotal()).compareTo(other.isSetLinkstotal()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinkstotal()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.linkstotal, other.linkstotal); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLinks()).compareTo(other.isSetLinks()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinks()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, other.links); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFids()).compareTo(other.isSetFids()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFids()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, other.fids); + 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 void read(org.apache.thrift.protocol.TProtocol prot, PackageData struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(13); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } - if (incoming.get(1)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(2)) { - struct.folder = iprot.readString(); - struct.setFolderIsSet(true); - } - if (incoming.get(3)) { - struct.site = iprot.readString(); - struct.setSiteIsSet(true); - } - if (incoming.get(4)) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); - } - if (incoming.get(5)) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(true); - } - if (incoming.get(6)) { - struct.order = iprot.readI16(); - struct.setOrderIsSet(true); - } - if (incoming.get(7)) { - struct.linksdone = iprot.readI16(); - struct.setLinksdoneIsSet(true); - } - if (incoming.get(8)) { - struct.sizedone = iprot.readI64(); - struct.setSizedoneIsSet(true); - } - if (incoming.get(9)) { - struct.sizetotal = iprot.readI64(); - struct.setSizetotalIsSet(true); - } - if (incoming.get(10)) { - struct.linkstotal = iprot.readI16(); - struct.setLinkstotalIsSet(true); - } - if (incoming.get(11)) { - { - org.apache.thrift.protocol.TList _list18 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.links = new ArrayList<FileData>(_list18.size); - for (int _i19 = 0; _i19 < _list18.size; ++_i19) - { - FileData _elem20; // required - _elem20 = new FileData(); - _elem20.read(iprot); - struct.links.add(_elem20); - } - } - struct.setLinksIsSet(true); - } - if (incoming.get(12)) { - { - org.apache.thrift.protocol.TList _list21 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.fids = new ArrayList<Integer>(_list21.size); - for (int _i22 = 0; _i22 < _list21.size; ++_i22) - { - int _elem23; // required - _elem23 = iprot.readI32(); - struct.fids.add(_elem23); - } - } - struct.setFidsIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("PackageData("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("folder:"); + if (this.folder == null) { + sb.append("null"); + } else { + sb.append(this.folder); + } + first = false; + if (!first) sb.append(", "); + sb.append("site:"); + if (this.site == null) { + sb.append("null"); + } else { + sb.append(this.site); + } + first = false; + if (!first) sb.append(", "); + sb.append("password:"); + if (this.password == null) { + sb.append("null"); + } else { + sb.append(this.password); + } + first = false; + if (!first) sb.append(", "); + sb.append("dest:"); + if (this.dest == null) { + sb.append("null"); + } else { + sb.append(this.dest); + } + first = false; + if (!first) sb.append(", "); + sb.append("order:"); + sb.append(this.order); + first = false; + if (isSetLinksdone()) { + if (!first) sb.append(", "); + sb.append("linksdone:"); + sb.append(this.linksdone); + first = false; + } + if (isSetSizedone()) { + if (!first) sb.append(", "); + sb.append("sizedone:"); + sb.append(this.sizedone); + first = false; + } + if (isSetSizetotal()) { + if (!first) sb.append(", "); + sb.append("sizetotal:"); + sb.append(this.sizetotal); + first = false; + } + if (isSetLinkstotal()) { + if (!first) sb.append(", "); + sb.append("linkstotal:"); + sb.append(this.linkstotal); + first = false; + } + if (isSetLinks()) { + if (!first) sb.append(", "); + sb.append("links:"); + if (this.links == null) { + sb.append("null"); + } else { + sb.append(this.links); + } + first = false; + } + if (isSetFids()) { + if (!first) sb.append(", "); + sb.append("fids:"); + if (this.fids == null) { + sb.append("null"); + } else { + sb.append(this.fids); + } + first = false; + } + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 PackageDataStandardSchemeFactory implements SchemeFactory { + public PackageDataStandardScheme getScheme() { + return new PackageDataStandardScheme(); + } + } + + private static class PackageDataStandardScheme extends StandardScheme<PackageData> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, PackageData 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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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 3: // FOLDER + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.folder = iprot.readString(); + struct.setFolderIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // SITE + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.site = iprot.readString(); + struct.setSiteIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // PASSWORD + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // DEST + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // ORDER + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.order = iprot.readI16(); + struct.setOrderIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 8: // LINKSDONE + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.linksdone = iprot.readI16(); + struct.setLinksdoneIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 9: // SIZEDONE + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.sizedone = iprot.readI64(); + struct.setSizedoneIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 10: // SIZETOTAL + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.sizetotal = iprot.readI64(); + struct.setSizetotalIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 11: // LINKSTOTAL + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.linkstotal = iprot.readI16(); + struct.setLinkstotalIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 12: // LINKS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list8 = iprot.readListBegin(); + struct.links = new ArrayList<FileData>(_list8.size); + FileData _elem9; + for (int _i10 = 0; _i10 < _list8.size; ++_i10) { + _elem9 = new FileData(); + _elem9.read(iprot); + struct.links.add(_elem9); + } + iprot.readListEnd(); + } + struct.setLinksIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 13: // FIDS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list11 = iprot.readListBegin(); + struct.fids = new ArrayList<Integer>(_list11.size); + int _elem12; + for (int _i13 = 0; _i13 < _list11.size; ++_i13) { + _elem12 = iprot.readI32(); + struct.fids.add(_elem12); + } + iprot.readListEnd(); + } + struct.setFidsIsSet(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, PackageData struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + if (struct.folder != null) { + oprot.writeFieldBegin(FOLDER_FIELD_DESC); + oprot.writeString(struct.folder); + oprot.writeFieldEnd(); + } + if (struct.site != null) { + oprot.writeFieldBegin(SITE_FIELD_DESC); + oprot.writeString(struct.site); + oprot.writeFieldEnd(); + } + if (struct.password != null) { + oprot.writeFieldBegin(PASSWORD_FIELD_DESC); + oprot.writeString(struct.password); + oprot.writeFieldEnd(); + } + if (struct.dest != null) { + oprot.writeFieldBegin(DEST_FIELD_DESC); + oprot.writeI32(struct.dest.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(ORDER_FIELD_DESC); + oprot.writeI16(struct.order); + oprot.writeFieldEnd(); + if (struct.isSetLinksdone()) { + oprot.writeFieldBegin(LINKSDONE_FIELD_DESC); + oprot.writeI16(struct.linksdone); + oprot.writeFieldEnd(); + } + if (struct.isSetSizedone()) { + oprot.writeFieldBegin(SIZEDONE_FIELD_DESC); + oprot.writeI64(struct.sizedone); + oprot.writeFieldEnd(); + } + if (struct.isSetSizetotal()) { + oprot.writeFieldBegin(SIZETOTAL_FIELD_DESC); + oprot.writeI64(struct.sizetotal); + oprot.writeFieldEnd(); + } + if (struct.isSetLinkstotal()) { + oprot.writeFieldBegin(LINKSTOTAL_FIELD_DESC); + oprot.writeI16(struct.linkstotal); + oprot.writeFieldEnd(); + } + if (struct.links != null) { + if (struct.isSetLinks()) { + oprot.writeFieldBegin(LINKS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.links.size())); + for (FileData _iter14 : struct.links) { + _iter14.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } + if (struct.fids != null) { + if (struct.isSetFids()) { + oprot.writeFieldBegin(FIDS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); + for (int _iter15 : struct.fids) { + oprot.writeI32(_iter15); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class PackageDataTupleSchemeFactory implements SchemeFactory { + public PackageDataTupleScheme getScheme() { + return new PackageDataTupleScheme(); + } + } + + private static class PackageDataTupleScheme extends TupleScheme<PackageData> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, PackageData struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + if (struct.isSetName()) { + optionals.set(1); + } + if (struct.isSetFolder()) { + optionals.set(2); + } + if (struct.isSetSite()) { + optionals.set(3); + } + if (struct.isSetPassword()) { + optionals.set(4); + } + if (struct.isSetDest()) { + optionals.set(5); + } + if (struct.isSetOrder()) { + optionals.set(6); + } + if (struct.isSetLinksdone()) { + optionals.set(7); + } + if (struct.isSetSizedone()) { + optionals.set(8); + } + if (struct.isSetSizetotal()) { + optionals.set(9); + } + if (struct.isSetLinkstotal()) { + optionals.set(10); + } + if (struct.isSetLinks()) { + optionals.set(11); + } + if (struct.isSetFids()) { + optionals.set(12); + } + oprot.writeBitSet(optionals, 13); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetFolder()) { + oprot.writeString(struct.folder); + } + if (struct.isSetSite()) { + oprot.writeString(struct.site); + } + if (struct.isSetPassword()) { + oprot.writeString(struct.password); + } + if (struct.isSetDest()) { + oprot.writeI32(struct.dest.getValue()); + } + if (struct.isSetOrder()) { + oprot.writeI16(struct.order); + } + if (struct.isSetLinksdone()) { + oprot.writeI16(struct.linksdone); + } + if (struct.isSetSizedone()) { + oprot.writeI64(struct.sizedone); + } + if (struct.isSetSizetotal()) { + oprot.writeI64(struct.sizetotal); + } + if (struct.isSetLinkstotal()) { + oprot.writeI16(struct.linkstotal); + } + if (struct.isSetLinks()) { + { + oprot.writeI32(struct.links.size()); + for (FileData _iter16 : struct.links) { + _iter16.write(oprot); + } + } + } + if (struct.isSetFids()) { + { + oprot.writeI32(struct.fids.size()); + for (int _iter17 : struct.fids) { + oprot.writeI32(_iter17); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, PackageData struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(13); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + if (incoming.get(1)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(2)) { + struct.folder = iprot.readString(); + struct.setFolderIsSet(true); + } + if (incoming.get(3)) { + struct.site = iprot.readString(); + struct.setSiteIsSet(true); + } + if (incoming.get(4)) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } + if (incoming.get(5)) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(true); + } + if (incoming.get(6)) { + struct.order = iprot.readI16(); + struct.setOrderIsSet(true); + } + if (incoming.get(7)) { + struct.linksdone = iprot.readI16(); + struct.setLinksdoneIsSet(true); + } + if (incoming.get(8)) { + struct.sizedone = iprot.readI64(); + struct.setSizedoneIsSet(true); + } + if (incoming.get(9)) { + struct.sizetotal = iprot.readI64(); + struct.setSizetotalIsSet(true); + } + if (incoming.get(10)) { + struct.linkstotal = iprot.readI16(); + struct.setLinkstotalIsSet(true); + } + if (incoming.get(11)) { + { + org.apache.thrift.protocol.TList _list18 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.links = new ArrayList<FileData>(_list18.size); + FileData _elem19; + for (int _i20 = 0; _i20 < _list18.size; ++_i20) { + _elem19 = new FileData(); + _elem19.read(iprot); + struct.links.add(_elem19); + } + } + struct.setLinksIsSet(true); + } + if (incoming.get(12)) { + { + org.apache.thrift.protocol.TList _list21 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.fids = new ArrayList<Integer>(_list21.size); + int _elem22; + for (int _i23 = 0; _i23 < _list21.size; ++_i23) { + _elem22 = iprot.readI32(); + struct.fids.add(_elem22); + } + } + struct.setFidsIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/PackageDoesNotExists.java b/app/src/main/java/org/pyload/thrift/PackageDoesNotExists.java index 6376818..65f3667 100644 --- a/app/src/main/java/org/pyload/thrift/PackageDoesNotExists.java +++ b/app/src/main/java/org/pyload/thrift/PackageDoesNotExists.java @@ -1,381 +1,419 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class PackageDoesNotExists extends TException implements org.apache.thrift.TBase<PackageDoesNotExists, PackageDoesNotExists._Fields>, java.io.Serializable, Cloneable, Comparable<PackageDoesNotExists>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PackageDoesNotExists"); + + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new PackageDoesNotExistsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new PackageDoesNotExistsTupleSchemeFactory()); + } -public class PackageDoesNotExists extends Exception implements org.apache.thrift.TBase<PackageDoesNotExists, PackageDoesNotExists._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PackageDoesNotExists"); + public int pid; // required - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new PackageDoesNotExistsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new PackageDoesNotExistsTupleSchemeFactory()); - } + out.writeInt(pid); + } - public int pid; // required + @Override + public int describeContents() { + return 0; + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - PID((short)1, "pid"); + public PackageDoesNotExists(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + this.pid = in.readInt(); + } + + public static final android.os.Parcelable.Creator<PackageDoesNotExists> CREATOR = new android.os.Parcelable.Creator<PackageDoesNotExists>() { + @Override + public PackageDoesNotExists[] newArray(int size) { + return new PackageDoesNotExists[size]; + } + + @Override + public PackageDoesNotExists createFromParcel(android.os.Parcel in) { + return new PackageDoesNotExists(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); + + 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: // PID + return PID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PackageDoesNotExists.class, metaDataMap); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // PID - return PID; - default: - return null; - } + public PackageDoesNotExists() { } - /** - * 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; + public PackageDoesNotExists( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - 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; + public PackageDoesNotExists(PackageDoesNotExists other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; } - } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(PackageDoesNotExists.class, metaDataMap); - } - - public PackageDoesNotExists() { - } - - public PackageDoesNotExists( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public PackageDoesNotExists(PackageDoesNotExists other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } - - public PackageDoesNotExists deepCopy() { - return new PackageDoesNotExists(this); - } - - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } - - public int getPid() { - return this.pid; - } - - public PackageDoesNotExists setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } - - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } - - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } - - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); - - } - 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof PackageDoesNotExists) - return this.equals((PackageDoesNotExists)that); - return false; - } - - public boolean equals(PackageDoesNotExists that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; + public PackageDoesNotExists deepCopy() { + return new PackageDoesNotExists(this); } - return true; - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } - @Override - public int hashCode() { - return 0; - } + public int getPid() { + return this.pid; + } - public int compareTo(PackageDoesNotExists other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); + public PackageDoesNotExists setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; } - int lastComparison = 0; - PackageDoesNotExists typedOther = (PackageDoesNotExists)other; + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } + + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); } - return 0; - } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - 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); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("PackageDoesNotExists("); - boolean first = true; + } + throw new IllegalStateException(); + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + /** 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(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + switch (field) { + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof PackageDoesNotExists) + return this.equals((PackageDoesNotExists) that); + return false; } - } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); + public boolean equals(PackageDoesNotExists that) { + if (that == null) + return false; + + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } + + return true; } - } - private static class PackageDoesNotExistsStandardSchemeFactory implements SchemeFactory { - public PackageDoesNotExistsStandardScheme getScheme() { - return new PackageDoesNotExistsStandardScheme(); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); + + return list.hashCode(); } - } - private static class PackageDoesNotExistsStandardScheme extends StandardScheme<PackageDoesNotExists> { + @Override + public int compareTo(PackageDoesNotExists other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void read(org.apache.thrift.protocol.TProtocol iprot, PackageDoesNotExists 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; + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; } - switch (schemeField.id) { - case 1: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + 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); + } - // 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) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - public void write(org.apache.thrift.protocol.TProtocol oprot, PackageDoesNotExists struct) throws org.apache.thrift.TException { - struct.validate(); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("PackageDoesNotExists("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 PackageDoesNotExistsTupleSchemeFactory implements SchemeFactory { - public PackageDoesNotExistsTupleScheme getScheme() { - return new PackageDoesNotExistsTupleScheme(); + private static class PackageDoesNotExistsStandardSchemeFactory implements SchemeFactory { + public PackageDoesNotExistsStandardScheme getScheme() { + return new PackageDoesNotExistsStandardScheme(); + } } - } - private static class PackageDoesNotExistsTupleScheme extends TupleScheme<PackageDoesNotExists> { + private static class PackageDoesNotExistsStandardScheme extends StandardScheme<PackageDoesNotExists> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, PackageDoesNotExists 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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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, PackageDoesNotExists struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, PackageDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, PackageDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } - } - } + private static class PackageDoesNotExistsTupleSchemeFactory implements SchemeFactory { + public PackageDoesNotExistsTupleScheme getScheme() { + return new PackageDoesNotExistsTupleScheme(); + } + } + + private static class PackageDoesNotExistsTupleScheme extends TupleScheme<PackageDoesNotExists> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, PackageDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, PackageDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/Pyload.java b/app/src/main/java/org/pyload/thrift/Pyload.java index fcb65a3..bc7dc5d 100644 --- a/app/src/main/java/org/pyload/thrift/Pyload.java +++ b/app/src/main/java/org/pyload/thrift/Pyload.java @@ -1,54706 +1,63462 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.TException; +import org.apache.thrift.async.AsyncMethodCallback; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; +import org.apache.thrift.server.AbstractNonblockingServer.AsyncFrameBuffer; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.nio.ByteBuffer; import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.Arrays; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) public class Pyload { - public interface Iface { + public interface Iface { - public String getConfigValue(String category, String option, String section) throws org.apache.thrift.TException; + public String getConfigValue(String category, String option, String section) throws org.apache.thrift.TException; - public void setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException; + public void setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException; - public Map<String,ConfigSection> getConfig() throws org.apache.thrift.TException; + public Map<String, ConfigSection> getConfig() throws org.apache.thrift.TException; - public Map<String,ConfigSection> getPluginConfig() throws org.apache.thrift.TException; + public Map<String, ConfigSection> getPluginConfig() throws org.apache.thrift.TException; - public void pauseServer() throws org.apache.thrift.TException; + public void pauseServer() throws org.apache.thrift.TException; - public void unpauseServer() throws org.apache.thrift.TException; + public void unpauseServer() throws org.apache.thrift.TException; - public boolean togglePause() throws org.apache.thrift.TException; + public boolean togglePause() throws org.apache.thrift.TException; - public ServerStatus statusServer() throws org.apache.thrift.TException; + public ServerStatus statusServer() throws org.apache.thrift.TException; - public long freeSpace() throws org.apache.thrift.TException; + public long freeSpace() throws org.apache.thrift.TException; - public String getServerVersion() throws org.apache.thrift.TException; + public String getServerVersion() throws org.apache.thrift.TException; - public void kill() throws org.apache.thrift.TException; + public void kill() throws org.apache.thrift.TException; - public void restart() throws org.apache.thrift.TException; + public void restart() throws org.apache.thrift.TException; - public List<String> getLog(int offset) throws org.apache.thrift.TException; + public List<String> getLog(int offset) throws org.apache.thrift.TException; - public boolean isTimeDownload() throws org.apache.thrift.TException; + public boolean isTimeDownload() throws org.apache.thrift.TException; - public boolean isTimeReconnect() throws org.apache.thrift.TException; + public boolean isTimeReconnect() throws org.apache.thrift.TException; - public boolean toggleReconnect() throws org.apache.thrift.TException; + public boolean toggleReconnect() throws org.apache.thrift.TException; - public Map<String,List<String>> generatePackages(List<String> links) throws org.apache.thrift.TException; + public Map<String, List<String>> generatePackages(List<String> links) throws org.apache.thrift.TException; - public Map<String,List<String>> checkURLs(List<String> urls) throws org.apache.thrift.TException; + public Map<String, List<String>> checkURLs(List<String> urls) throws org.apache.thrift.TException; - public Map<String,List<String>> parseURLs(String html, String url) throws org.apache.thrift.TException; + public Map<String, List<String>> parseURLs(String html, String url) throws org.apache.thrift.TException; - public OnlineCheck checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException; + public OnlineCheck checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException; - public OnlineCheck checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException; + public OnlineCheck checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException; - public OnlineCheck pollResults(int rid) throws org.apache.thrift.TException; + public OnlineCheck pollResults(int rid) throws org.apache.thrift.TException; - public List<DownloadInfo> statusDownloads() throws org.apache.thrift.TException; + public List<DownloadInfo> statusDownloads() throws org.apache.thrift.TException; - public PackageData getPackageData(int pid) throws PackageDoesNotExists, org.apache.thrift.TException; + public PackageData getPackageData(int pid) throws PackageDoesNotExists, org.apache.thrift.TException; - public PackageData getPackageInfo(int pid) throws PackageDoesNotExists, org.apache.thrift.TException; + public PackageData getPackageInfo(int pid) throws PackageDoesNotExists, org.apache.thrift.TException; - public FileData getFileData(int fid) throws FileDoesNotExists, org.apache.thrift.TException; + public FileData getFileData(int fid) throws FileDoesNotExists, org.apache.thrift.TException; - public List<PackageData> getQueue() throws org.apache.thrift.TException; + public List<PackageData> getQueue() throws org.apache.thrift.TException; - public List<PackageData> getCollector() throws org.apache.thrift.TException; + public List<PackageData> getCollector() throws org.apache.thrift.TException; - public List<PackageData> getQueueData() throws org.apache.thrift.TException; + public List<PackageData> getQueueData() throws org.apache.thrift.TException; - public List<PackageData> getCollectorData() throws org.apache.thrift.TException; + public List<PackageData> getCollectorData() throws org.apache.thrift.TException; - public Map<Short,Integer> getPackageOrder(Destination destination) throws org.apache.thrift.TException; + public Map<Short, Integer> getPackageOrder(Destination destination) throws org.apache.thrift.TException; - public Map<Short,Integer> getFileOrder(int pid) throws org.apache.thrift.TException; + public Map<Short, Integer> getFileOrder(int pid) throws org.apache.thrift.TException; - public List<Integer> generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException; + public List<Integer> generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException; - public int addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException; + public int addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException; - public void addFiles(int pid, List<String> links) throws org.apache.thrift.TException; + public void addFiles(int pid, List<String> links) throws org.apache.thrift.TException; - public void uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException; + public void uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException; - public void deleteFiles(List<Integer> fids) throws org.apache.thrift.TException; + public void deleteFiles(List<Integer> fids) throws org.apache.thrift.TException; - public void deletePackages(List<Integer> pids) throws org.apache.thrift.TException; + public void deletePackages(List<Integer> pids) throws org.apache.thrift.TException; - public void pushToQueue(int pid) throws org.apache.thrift.TException; + public void pushToQueue(int pid) throws org.apache.thrift.TException; - public void pullFromQueue(int pid) throws org.apache.thrift.TException; + public void pullFromQueue(int pid) throws org.apache.thrift.TException; - public void restartPackage(int pid) throws org.apache.thrift.TException; + public void restartPackage(int pid) throws org.apache.thrift.TException; - public void restartFile(int fid) throws org.apache.thrift.TException; + public void restartFile(int fid) throws org.apache.thrift.TException; - public void recheckPackage(int pid) throws org.apache.thrift.TException; + public void recheckPackage(int pid) throws org.apache.thrift.TException; - public void stopAllDownloads() throws org.apache.thrift.TException; + public void stopAllDownloads() throws org.apache.thrift.TException; - public void stopDownloads(List<Integer> fids) throws org.apache.thrift.TException; + public void stopDownloads(List<Integer> fids) throws org.apache.thrift.TException; - public void setPackageName(int pid, String name) throws org.apache.thrift.TException; + public void setPackageName(int pid, String name) throws org.apache.thrift.TException; - public void movePackage(Destination destination, int pid) throws org.apache.thrift.TException; + public void movePackage(Destination destination, int pid) throws org.apache.thrift.TException; - public void moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException; + public void moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException; - public void orderPackage(int pid, short position) throws org.apache.thrift.TException; + public void orderPackage(int pid, short position) throws org.apache.thrift.TException; - public void orderFile(int fid, short position) throws org.apache.thrift.TException; + public void orderFile(int fid, short position) throws org.apache.thrift.TException; - public void setPackageData(int pid, Map<String,String> data) throws PackageDoesNotExists, org.apache.thrift.TException; + public void setPackageData(int pid, Map<String, String> data) throws PackageDoesNotExists, org.apache.thrift.TException; - public List<Integer> deleteFinished() throws org.apache.thrift.TException; + public List<Integer> deleteFinished() throws org.apache.thrift.TException; - public void restartFailed() throws org.apache.thrift.TException; + public void restartFailed() throws org.apache.thrift.TException; - public boolean isCaptchaWaiting() throws org.apache.thrift.TException; + public List<EventInfo> getEvents(String uuid) throws org.apache.thrift.TException; - public CaptchaTask getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException; + public List<AccountInfo> getAccounts(boolean refresh) throws org.apache.thrift.TException; - public String getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException; + public List<String> getAccountTypes() throws org.apache.thrift.TException; - public void setCaptchaResult(int tid, String result) throws org.apache.thrift.TException; + public void updateAccount(String plugin, String account, String password, Map<String, String> options) throws org.apache.thrift.TException; - public List<EventInfo> getEvents(String uuid) throws org.apache.thrift.TException; + public void removeAccount(String plugin, String account) throws org.apache.thrift.TException; - public List<AccountInfo> getAccounts(boolean refresh) throws org.apache.thrift.TException; + public boolean login(String username, String password) throws org.apache.thrift.TException; - public List<String> getAccountTypes() throws org.apache.thrift.TException; + public UserData getUserData(String username, String password) throws org.apache.thrift.TException; - public void updateAccount(String plugin, String account, String password, Map<String,String> options) throws org.apache.thrift.TException; + public Map<String, UserData> getAllUserData() throws org.apache.thrift.TException; - public void removeAccount(String plugin, String account) throws org.apache.thrift.TException; + public Map<String, Map<String, String>> getServices() throws org.apache.thrift.TException; - public boolean login(String username, String password) throws org.apache.thrift.TException; + public boolean hasService(String plugin, String func) throws org.apache.thrift.TException; - public UserData getUserData(String username, String password) throws org.apache.thrift.TException; + public String call(ServiceCall info) throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException; - public Map<String,UserData> getAllUserData() throws org.apache.thrift.TException; + public Map<String, Map<String, String>> getAllInfo() throws org.apache.thrift.TException; - public Map<String,Map<String,String>> getServices() throws org.apache.thrift.TException; + public Map<String, String> getInfoByPlugin(String plugin) throws org.apache.thrift.TException; - public boolean hasService(String plugin, String func) throws org.apache.thrift.TException; + public boolean isCaptchaWaiting() throws org.apache.thrift.TException; - public String call(ServiceCall info) throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException; + public CaptchaTask getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException; - public Map<String,Map<String,String>> getAllInfo() throws org.apache.thrift.TException; + public String getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException; - public Map<String,String> getInfoByPlugin(String plugin) throws org.apache.thrift.TException; + public void setCaptchaResult(int tid, String result) throws org.apache.thrift.TException; - } - - public interface AsyncIface { + } - public void getConfigValue(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getConfigValue_call> resultHandler) throws org.apache.thrift.TException; + public interface AsyncIface { - public void setConfigValue(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setConfigValue_call> resultHandler) throws org.apache.thrift.TException; + public void getConfigValue(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getConfig(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getConfig_call> resultHandler) throws org.apache.thrift.TException; + public void setConfigValue(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getPluginConfig(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getPluginConfig_call> resultHandler) throws org.apache.thrift.TException; + public void getConfig(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void pauseServer(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.pauseServer_call> resultHandler) throws org.apache.thrift.TException; + public void getPluginConfig(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void unpauseServer(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.unpauseServer_call> resultHandler) throws org.apache.thrift.TException; + public void pauseServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void togglePause(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.togglePause_call> resultHandler) throws org.apache.thrift.TException; + public void unpauseServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void statusServer(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.statusServer_call> resultHandler) throws org.apache.thrift.TException; + public void togglePause(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void freeSpace(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.freeSpace_call> resultHandler) throws org.apache.thrift.TException; + public void statusServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getServerVersion(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getServerVersion_call> resultHandler) throws org.apache.thrift.TException; + public void freeSpace(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void kill(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.kill_call> resultHandler) throws org.apache.thrift.TException; + public void getServerVersion(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void restart(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.restart_call> resultHandler) throws org.apache.thrift.TException; + public void kill(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getLog(int offset, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getLog_call> resultHandler) throws org.apache.thrift.TException; + public void restart(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void isTimeDownload(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.isTimeDownload_call> resultHandler) throws org.apache.thrift.TException; + public void getLog(int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void isTimeReconnect(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.isTimeReconnect_call> resultHandler) throws org.apache.thrift.TException; + public void isTimeDownload(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void toggleReconnect(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.toggleReconnect_call> resultHandler) throws org.apache.thrift.TException; + public void isTimeReconnect(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void generatePackages(List<String> links, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.generatePackages_call> resultHandler) throws org.apache.thrift.TException; + public void toggleReconnect(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void checkURLs(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkURLs_call> resultHandler) throws org.apache.thrift.TException; + public void generatePackages(List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void parseURLs(String html, String url, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.parseURLs_call> resultHandler) throws org.apache.thrift.TException; + public void checkURLs(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void checkOnlineStatus(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkOnlineStatus_call> resultHandler) throws org.apache.thrift.TException; + public void parseURLs(String html, String url, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.checkOnlineStatusContainer_call> resultHandler) throws org.apache.thrift.TException; + public void checkOnlineStatus(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void pollResults(int rid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.pollResults_call> resultHandler) throws org.apache.thrift.TException; + public void checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void statusDownloads(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.statusDownloads_call> resultHandler) throws org.apache.thrift.TException; + public void pollResults(int rid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getPackageData(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getPackageData_call> resultHandler) throws org.apache.thrift.TException; + public void statusDownloads(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getPackageInfo(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getPackageInfo_call> resultHandler) throws org.apache.thrift.TException; + public void getPackageData(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getFileData(int fid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getFileData_call> resultHandler) throws org.apache.thrift.TException; + public void getPackageInfo(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getQueue(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getQueue_call> resultHandler) throws org.apache.thrift.TException; + public void getFileData(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getCollector(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getCollector_call> resultHandler) throws org.apache.thrift.TException; + public void getQueue(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getQueueData(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getQueueData_call> resultHandler) throws org.apache.thrift.TException; + public void getCollector(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getCollectorData(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getCollectorData_call> resultHandler) throws org.apache.thrift.TException; + public void getQueueData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getPackageOrder(Destination destination, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getPackageOrder_call> resultHandler) throws org.apache.thrift.TException; + public void getCollectorData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getFileOrder(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getFileOrder_call> resultHandler) throws org.apache.thrift.TException; + public void getPackageOrder(Destination destination, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void generateAndAddPackages(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.generateAndAddPackages_call> resultHandler) throws org.apache.thrift.TException; + public void getFileOrder(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void addPackage(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addPackage_call> resultHandler) throws org.apache.thrift.TException; + public void generateAndAddPackages(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void addFiles(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.addFiles_call> resultHandler) throws org.apache.thrift.TException; + public void addPackage(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void uploadContainer(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.uploadContainer_call> resultHandler) throws org.apache.thrift.TException; + public void addFiles(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void deleteFiles(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteFiles_call> resultHandler) throws org.apache.thrift.TException; + public void uploadContainer(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void deletePackages(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deletePackages_call> resultHandler) throws org.apache.thrift.TException; + public void deleteFiles(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void pushToQueue(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.pushToQueue_call> resultHandler) throws org.apache.thrift.TException; + public void deletePackages(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void pullFromQueue(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.pullFromQueue_call> resultHandler) throws org.apache.thrift.TException; + public void pushToQueue(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void restartPackage(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.restartPackage_call> resultHandler) throws org.apache.thrift.TException; + public void pullFromQueue(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void restartFile(int fid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.restartFile_call> resultHandler) throws org.apache.thrift.TException; + public void restartPackage(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void recheckPackage(int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.recheckPackage_call> resultHandler) throws org.apache.thrift.TException; + public void restartFile(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void stopAllDownloads(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.stopAllDownloads_call> resultHandler) throws org.apache.thrift.TException; + public void recheckPackage(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void stopDownloads(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.stopDownloads_call> resultHandler) throws org.apache.thrift.TException; + public void stopAllDownloads(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void setPackageName(int pid, String name, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setPackageName_call> resultHandler) throws org.apache.thrift.TException; + public void stopDownloads(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void movePackage(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.movePackage_call> resultHandler) throws org.apache.thrift.TException; + public void setPackageName(int pid, String name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void moveFiles(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.moveFiles_call> resultHandler) throws org.apache.thrift.TException; + public void movePackage(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void orderPackage(int pid, short position, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.orderPackage_call> resultHandler) throws org.apache.thrift.TException; + public void moveFiles(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void orderFile(int fid, short position, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.orderFile_call> resultHandler) throws org.apache.thrift.TException; + public void orderPackage(int pid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void setPackageData(int pid, Map<String,String> data, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setPackageData_call> resultHandler) throws org.apache.thrift.TException; + public void orderFile(int fid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void deleteFinished(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.deleteFinished_call> resultHandler) throws org.apache.thrift.TException; + public void setPackageData(int pid, Map<String, String> data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void restartFailed(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.restartFailed_call> resultHandler) throws org.apache.thrift.TException; + public void deleteFinished(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void isCaptchaWaiting(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.isCaptchaWaiting_call> resultHandler) throws org.apache.thrift.TException; + public void restartFailed(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getCaptchaTask(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getCaptchaTask_call> resultHandler) throws org.apache.thrift.TException; + public void getEvents(String uuid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getCaptchaTaskStatus(int tid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getCaptchaTaskStatus_call> resultHandler) throws org.apache.thrift.TException; + public void getAccounts(boolean refresh, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void setCaptchaResult(int tid, String result, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.setCaptchaResult_call> resultHandler) throws org.apache.thrift.TException; + public void getAccountTypes(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getEvents(String uuid, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getEvents_call> resultHandler) throws org.apache.thrift.TException; + public void updateAccount(String plugin, String account, String password, Map<String, String> options, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getAccounts(boolean refresh, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAccounts_call> resultHandler) throws org.apache.thrift.TException; + public void removeAccount(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getAccountTypes(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAccountTypes_call> resultHandler) throws org.apache.thrift.TException; + public void login(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void updateAccount(String plugin, String account, String password, Map<String,String> options, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateAccount_call> resultHandler) throws org.apache.thrift.TException; + public void getUserData(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void removeAccount(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.removeAccount_call> resultHandler) throws org.apache.thrift.TException; + public void getAllUserData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void login(String username, String password, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.login_call> resultHandler) throws org.apache.thrift.TException; + public void getServices(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getUserData(String username, String password, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getUserData_call> resultHandler) throws org.apache.thrift.TException; + public void hasService(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getAllUserData(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllUserData_call> resultHandler) throws org.apache.thrift.TException; + public void call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getServices(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getServices_call> resultHandler) throws org.apache.thrift.TException; + public void getAllInfo(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void hasService(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.hasService_call> resultHandler) throws org.apache.thrift.TException; + public void getInfoByPlugin(String plugin, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.call_call> resultHandler) throws org.apache.thrift.TException; + public void isCaptchaWaiting(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getAllInfo(org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllInfo_call> resultHandler) throws org.apache.thrift.TException; + public void getCaptchaTask(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - public void getInfoByPlugin(String plugin, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getInfoByPlugin_call> resultHandler) throws org.apache.thrift.TException; + public void getCaptchaTaskStatus(int tid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException; - } + public void setCaptchaResult(int tid, String result, org.apache.thrift.async.AsyncMethodCallback 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 static class Client extends org.apache.thrift.TServiceClient implements Iface { + public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> { + public Factory() { + } - public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { - super(iprot, oprot); - } + public Client getClient(org.apache.thrift.protocol.TProtocol prot) { + return new Client(prot); + } - public String getConfigValue(String category, String option, String section) throws org.apache.thrift.TException - { - send_getConfigValue(category, option, section); - return recv_getConfigValue(); - } + public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { + return new Client(iprot, oprot); + } + } - public void send_getConfigValue(String category, String option, String section) throws org.apache.thrift.TException - { - getConfigValue_args args = new getConfigValue_args(); - args.setCategory(category); - args.setOption(option); - args.setSection(section); - sendBase("getConfigValue", args); - } + public Client(org.apache.thrift.protocol.TProtocol prot) { + super(prot, prot); + } - public String recv_getConfigValue() throws org.apache.thrift.TException - { - getConfigValue_result result = new getConfigValue_result(); - receiveBase(result, "getConfigValue"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result"); - } + public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { + super(iprot, oprot); + } - public void setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException - { - send_setConfigValue(category, option, value, section); - recv_setConfigValue(); - } + public String getConfigValue(String category, String option, String section) throws org.apache.thrift.TException { + send_getConfigValue(category, option, section); + return recv_getConfigValue(); + } - public void send_setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException - { - setConfigValue_args args = new setConfigValue_args(); - args.setCategory(category); - args.setOption(option); - args.setValue(value); - args.setSection(section); - sendBase("setConfigValue", args); - } + public void send_getConfigValue(String category, String option, String section) throws org.apache.thrift.TException { + getConfigValue_args args = new getConfigValue_args(); + args.setCategory(category); + args.setOption(option); + args.setSection(section); + sendBase("getConfigValue", args); + } - public void recv_setConfigValue() throws org.apache.thrift.TException - { - setConfigValue_result result = new setConfigValue_result(); - receiveBase(result, "setConfigValue"); - return; - } + public String recv_getConfigValue() throws org.apache.thrift.TException { + getConfigValue_result result = new getConfigValue_result(); + receiveBase(result, "getConfigValue"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getConfigValue failed: unknown result"); + } - public Map<String,ConfigSection> getConfig() throws org.apache.thrift.TException - { - send_getConfig(); - return recv_getConfig(); - } + public void setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException { + send_setConfigValue(category, option, value, section); + recv_setConfigValue(); + } - public void send_getConfig() throws org.apache.thrift.TException - { - getConfig_args args = new getConfig_args(); - sendBase("getConfig", args); - } + public void send_setConfigValue(String category, String option, String value, String section) throws org.apache.thrift.TException { + setConfigValue_args args = new setConfigValue_args(); + args.setCategory(category); + args.setOption(option); + args.setValue(value); + args.setSection(section); + sendBase("setConfigValue", args); + } - public Map<String,ConfigSection> recv_getConfig() throws org.apache.thrift.TException - { - getConfig_result result = new getConfig_result(); - receiveBase(result, "getConfig"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getConfig failed: unknown result"); - } + public void recv_setConfigValue() throws org.apache.thrift.TException { + setConfigValue_result result = new setConfigValue_result(); + receiveBase(result, "setConfigValue"); + return; + } - public Map<String,ConfigSection> getPluginConfig() throws org.apache.thrift.TException - { - send_getPluginConfig(); - return recv_getPluginConfig(); - } + public Map<String, ConfigSection> getConfig() throws org.apache.thrift.TException { + send_getConfig(); + return recv_getConfig(); + } - public void send_getPluginConfig() throws org.apache.thrift.TException - { - getPluginConfig_args args = new getPluginConfig_args(); - sendBase("getPluginConfig", args); - } + public void send_getConfig() throws org.apache.thrift.TException { + getConfig_args args = new getConfig_args(); + sendBase("getConfig", args); + } - public Map<String,ConfigSection> recv_getPluginConfig() throws org.apache.thrift.TException - { - getPluginConfig_result result = new getPluginConfig_result(); - receiveBase(result, "getPluginConfig"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result"); - } + public Map<String, ConfigSection> recv_getConfig() throws org.apache.thrift.TException { + getConfig_result result = new getConfig_result(); + receiveBase(result, "getConfig"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getConfig failed: unknown result"); + } - public void pauseServer() throws org.apache.thrift.TException - { - send_pauseServer(); - recv_pauseServer(); - } + public Map<String, ConfigSection> getPluginConfig() throws org.apache.thrift.TException { + send_getPluginConfig(); + return recv_getPluginConfig(); + } - public void send_pauseServer() throws org.apache.thrift.TException - { - pauseServer_args args = new pauseServer_args(); - sendBase("pauseServer", args); - } + public void send_getPluginConfig() throws org.apache.thrift.TException { + getPluginConfig_args args = new getPluginConfig_args(); + sendBase("getPluginConfig", args); + } - public void recv_pauseServer() throws org.apache.thrift.TException - { - pauseServer_result result = new pauseServer_result(); - receiveBase(result, "pauseServer"); - return; - } + public Map<String, ConfigSection> recv_getPluginConfig() throws org.apache.thrift.TException { + getPluginConfig_result result = new getPluginConfig_result(); + receiveBase(result, "getPluginConfig"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPluginConfig failed: unknown result"); + } - public void unpauseServer() throws org.apache.thrift.TException - { - send_unpauseServer(); - recv_unpauseServer(); - } + public void pauseServer() throws org.apache.thrift.TException { + send_pauseServer(); + recv_pauseServer(); + } - public void send_unpauseServer() throws org.apache.thrift.TException - { - unpauseServer_args args = new unpauseServer_args(); - sendBase("unpauseServer", args); - } + public void send_pauseServer() throws org.apache.thrift.TException { + pauseServer_args args = new pauseServer_args(); + sendBase("pauseServer", args); + } - public void recv_unpauseServer() throws org.apache.thrift.TException - { - unpauseServer_result result = new unpauseServer_result(); - receiveBase(result, "unpauseServer"); - return; - } + public void recv_pauseServer() throws org.apache.thrift.TException { + pauseServer_result result = new pauseServer_result(); + receiveBase(result, "pauseServer"); + return; + } - public boolean togglePause() throws org.apache.thrift.TException - { - send_togglePause(); - return recv_togglePause(); - } + public void unpauseServer() throws org.apache.thrift.TException { + send_unpauseServer(); + recv_unpauseServer(); + } - public void send_togglePause() throws org.apache.thrift.TException - { - togglePause_args args = new togglePause_args(); - sendBase("togglePause", args); - } + public void send_unpauseServer() throws org.apache.thrift.TException { + unpauseServer_args args = new unpauseServer_args(); + sendBase("unpauseServer", args); + } - public boolean recv_togglePause() throws org.apache.thrift.TException - { - togglePause_result result = new togglePause_result(); - receiveBase(result, "togglePause"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "togglePause failed: unknown result"); - } + public void recv_unpauseServer() throws org.apache.thrift.TException { + unpauseServer_result result = new unpauseServer_result(); + receiveBase(result, "unpauseServer"); + return; + } - public ServerStatus statusServer() throws org.apache.thrift.TException - { - send_statusServer(); - return recv_statusServer(); - } + public boolean togglePause() throws org.apache.thrift.TException { + send_togglePause(); + return recv_togglePause(); + } - public void send_statusServer() throws org.apache.thrift.TException - { - statusServer_args args = new statusServer_args(); - sendBase("statusServer", args); - } + public void send_togglePause() throws org.apache.thrift.TException { + togglePause_args args = new togglePause_args(); + sendBase("togglePause", args); + } - public ServerStatus recv_statusServer() throws org.apache.thrift.TException - { - statusServer_result result = new statusServer_result(); - receiveBase(result, "statusServer"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "statusServer failed: unknown result"); - } + public boolean recv_togglePause() throws org.apache.thrift.TException { + togglePause_result result = new togglePause_result(); + receiveBase(result, "togglePause"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "togglePause failed: unknown result"); + } - public long freeSpace() throws org.apache.thrift.TException - { - send_freeSpace(); - return recv_freeSpace(); - } + public ServerStatus statusServer() throws org.apache.thrift.TException { + send_statusServer(); + return recv_statusServer(); + } - public void send_freeSpace() throws org.apache.thrift.TException - { - freeSpace_args args = new freeSpace_args(); - sendBase("freeSpace", args); - } + public void send_statusServer() throws org.apache.thrift.TException { + statusServer_args args = new statusServer_args(); + sendBase("statusServer", args); + } - public long recv_freeSpace() throws org.apache.thrift.TException - { - freeSpace_result result = new freeSpace_result(); - receiveBase(result, "freeSpace"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "freeSpace failed: unknown result"); - } + public ServerStatus recv_statusServer() throws org.apache.thrift.TException { + statusServer_result result = new statusServer_result(); + receiveBase(result, "statusServer"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "statusServer failed: unknown result"); + } - public String getServerVersion() throws org.apache.thrift.TException - { - send_getServerVersion(); - return recv_getServerVersion(); - } + public long freeSpace() throws org.apache.thrift.TException { + send_freeSpace(); + return recv_freeSpace(); + } - public void send_getServerVersion() throws org.apache.thrift.TException - { - getServerVersion_args args = new getServerVersion_args(); - sendBase("getServerVersion", args); - } + public void send_freeSpace() throws org.apache.thrift.TException { + freeSpace_args args = new freeSpace_args(); + sendBase("freeSpace", args); + } - public String recv_getServerVersion() throws org.apache.thrift.TException - { - getServerVersion_result result = new getServerVersion_result(); - receiveBase(result, "getServerVersion"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result"); - } + public long recv_freeSpace() throws org.apache.thrift.TException { + freeSpace_result result = new freeSpace_result(); + receiveBase(result, "freeSpace"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "freeSpace failed: unknown result"); + } - public void kill() throws org.apache.thrift.TException - { - send_kill(); - recv_kill(); - } + public String getServerVersion() throws org.apache.thrift.TException { + send_getServerVersion(); + return recv_getServerVersion(); + } - public void send_kill() throws org.apache.thrift.TException - { - kill_args args = new kill_args(); - sendBase("kill", args); - } + public void send_getServerVersion() throws org.apache.thrift.TException { + getServerVersion_args args = new getServerVersion_args(); + sendBase("getServerVersion", args); + } - public void recv_kill() throws org.apache.thrift.TException - { - kill_result result = new kill_result(); - receiveBase(result, "kill"); - return; - } + public String recv_getServerVersion() throws org.apache.thrift.TException { + getServerVersion_result result = new getServerVersion_result(); + receiveBase(result, "getServerVersion"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getServerVersion failed: unknown result"); + } - public void restart() throws org.apache.thrift.TException - { - send_restart(); - recv_restart(); - } + public void kill() throws org.apache.thrift.TException { + send_kill(); + recv_kill(); + } - public void send_restart() throws org.apache.thrift.TException - { - restart_args args = new restart_args(); - sendBase("restart", args); - } + public void send_kill() throws org.apache.thrift.TException { + kill_args args = new kill_args(); + sendBase("kill", args); + } - public void recv_restart() throws org.apache.thrift.TException - { - restart_result result = new restart_result(); - receiveBase(result, "restart"); - return; - } + public void recv_kill() throws org.apache.thrift.TException { + kill_result result = new kill_result(); + receiveBase(result, "kill"); + return; + } - public List<String> getLog(int offset) throws org.apache.thrift.TException - { - send_getLog(offset); - return recv_getLog(); - } + public void restart() throws org.apache.thrift.TException { + send_restart(); + recv_restart(); + } - public void send_getLog(int offset) throws org.apache.thrift.TException - { - getLog_args args = new getLog_args(); - args.setOffset(offset); - sendBase("getLog", args); - } + public void send_restart() throws org.apache.thrift.TException { + restart_args args = new restart_args(); + sendBase("restart", args); + } - public List<String> recv_getLog() throws org.apache.thrift.TException - { - getLog_result result = new getLog_result(); - receiveBase(result, "getLog"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLog failed: unknown result"); - } + public void recv_restart() throws org.apache.thrift.TException { + restart_result result = new restart_result(); + receiveBase(result, "restart"); + return; + } - public boolean isTimeDownload() throws org.apache.thrift.TException - { - send_isTimeDownload(); - return recv_isTimeDownload(); - } + public List<String> getLog(int offset) throws org.apache.thrift.TException { + send_getLog(offset); + return recv_getLog(); + } - public void send_isTimeDownload() throws org.apache.thrift.TException - { - isTimeDownload_args args = new isTimeDownload_args(); - sendBase("isTimeDownload", args); - } + public void send_getLog(int offset) throws org.apache.thrift.TException { + getLog_args args = new getLog_args(); + args.setOffset(offset); + sendBase("getLog", args); + } - public boolean recv_isTimeDownload() throws org.apache.thrift.TException - { - isTimeDownload_result result = new isTimeDownload_result(); - receiveBase(result, "isTimeDownload"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTimeDownload failed: unknown result"); - } + public List<String> recv_getLog() throws org.apache.thrift.TException { + getLog_result result = new getLog_result(); + receiveBase(result, "getLog"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getLog failed: unknown result"); + } - public boolean isTimeReconnect() throws org.apache.thrift.TException - { - send_isTimeReconnect(); - return recv_isTimeReconnect(); - } + public boolean isTimeDownload() throws org.apache.thrift.TException { + send_isTimeDownload(); + return recv_isTimeDownload(); + } - public void send_isTimeReconnect() throws org.apache.thrift.TException - { - isTimeReconnect_args args = new isTimeReconnect_args(); - sendBase("isTimeReconnect", args); - } + public void send_isTimeDownload() throws org.apache.thrift.TException { + isTimeDownload_args args = new isTimeDownload_args(); + sendBase("isTimeDownload", args); + } - public boolean recv_isTimeReconnect() throws org.apache.thrift.TException - { - isTimeReconnect_result result = new isTimeReconnect_result(); - receiveBase(result, "isTimeReconnect"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTimeReconnect failed: unknown result"); - } + public boolean recv_isTimeDownload() throws org.apache.thrift.TException { + isTimeDownload_result result = new isTimeDownload_result(); + receiveBase(result, "isTimeDownload"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTimeDownload failed: unknown result"); + } - public boolean toggleReconnect() throws org.apache.thrift.TException - { - send_toggleReconnect(); - return recv_toggleReconnect(); - } + public boolean isTimeReconnect() throws org.apache.thrift.TException { + send_isTimeReconnect(); + return recv_isTimeReconnect(); + } - public void send_toggleReconnect() throws org.apache.thrift.TException - { - toggleReconnect_args args = new toggleReconnect_args(); - sendBase("toggleReconnect", args); - } + public void send_isTimeReconnect() throws org.apache.thrift.TException { + isTimeReconnect_args args = new isTimeReconnect_args(); + sendBase("isTimeReconnect", args); + } - public boolean recv_toggleReconnect() throws org.apache.thrift.TException - { - toggleReconnect_result result = new toggleReconnect_result(); - receiveBase(result, "toggleReconnect"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "toggleReconnect failed: unknown result"); - } + public boolean recv_isTimeReconnect() throws org.apache.thrift.TException { + isTimeReconnect_result result = new isTimeReconnect_result(); + receiveBase(result, "isTimeReconnect"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isTimeReconnect failed: unknown result"); + } - public Map<String,List<String>> generatePackages(List<String> links) throws org.apache.thrift.TException - { - send_generatePackages(links); - return recv_generatePackages(); - } + public boolean toggleReconnect() throws org.apache.thrift.TException { + send_toggleReconnect(); + return recv_toggleReconnect(); + } - public void send_generatePackages(List<String> links) throws org.apache.thrift.TException - { - generatePackages_args args = new generatePackages_args(); - args.setLinks(links); - sendBase("generatePackages", args); - } + public void send_toggleReconnect() throws org.apache.thrift.TException { + toggleReconnect_args args = new toggleReconnect_args(); + sendBase("toggleReconnect", args); + } - public Map<String,List<String>> recv_generatePackages() throws org.apache.thrift.TException - { - generatePackages_result result = new generatePackages_result(); - receiveBase(result, "generatePackages"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result"); - } + public boolean recv_toggleReconnect() throws org.apache.thrift.TException { + toggleReconnect_result result = new toggleReconnect_result(); + receiveBase(result, "toggleReconnect"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "toggleReconnect failed: unknown result"); + } - public Map<String,List<String>> checkURLs(List<String> urls) throws org.apache.thrift.TException - { - send_checkURLs(urls); - return recv_checkURLs(); - } + public Map<String, List<String>> generatePackages(List<String> links) throws org.apache.thrift.TException { + send_generatePackages(links); + return recv_generatePackages(); + } - public void send_checkURLs(List<String> urls) throws org.apache.thrift.TException - { - checkURLs_args args = new checkURLs_args(); - args.setUrls(urls); - sendBase("checkURLs", args); - } + public void send_generatePackages(List<String> links) throws org.apache.thrift.TException { + generatePackages_args args = new generatePackages_args(); + args.setLinks(links); + sendBase("generatePackages", args); + } - public Map<String,List<String>> recv_checkURLs() throws org.apache.thrift.TException - { - checkURLs_result result = new checkURLs_result(); - receiveBase(result, "checkURLs"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkURLs failed: unknown result"); - } + public Map<String, List<String>> recv_generatePackages() throws org.apache.thrift.TException { + generatePackages_result result = new generatePackages_result(); + receiveBase(result, "generatePackages"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "generatePackages failed: unknown result"); + } - public Map<String,List<String>> parseURLs(String html, String url) throws org.apache.thrift.TException - { - send_parseURLs(html, url); - return recv_parseURLs(); - } + public Map<String, List<String>> checkURLs(List<String> urls) throws org.apache.thrift.TException { + send_checkURLs(urls); + return recv_checkURLs(); + } - public void send_parseURLs(String html, String url) throws org.apache.thrift.TException - { - parseURLs_args args = new parseURLs_args(); - args.setHtml(html); - args.setUrl(url); - sendBase("parseURLs", args); - } + public void send_checkURLs(List<String> urls) throws org.apache.thrift.TException { + checkURLs_args args = new checkURLs_args(); + args.setUrls(urls); + sendBase("checkURLs", args); + } - public Map<String,List<String>> recv_parseURLs() throws org.apache.thrift.TException - { - parseURLs_result result = new parseURLs_result(); - receiveBase(result, "parseURLs"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "parseURLs failed: unknown result"); - } + public Map<String, List<String>> recv_checkURLs() throws org.apache.thrift.TException { + checkURLs_result result = new checkURLs_result(); + receiveBase(result, "checkURLs"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkURLs failed: unknown result"); + } - public OnlineCheck checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException - { - send_checkOnlineStatus(urls); - return recv_checkOnlineStatus(); - } + public Map<String, List<String>> parseURLs(String html, String url) throws org.apache.thrift.TException { + send_parseURLs(html, url); + return recv_parseURLs(); + } - public void send_checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException - { - checkOnlineStatus_args args = new checkOnlineStatus_args(); - args.setUrls(urls); - sendBase("checkOnlineStatus", args); - } + public void send_parseURLs(String html, String url) throws org.apache.thrift.TException { + parseURLs_args args = new parseURLs_args(); + args.setHtml(html); + args.setUrl(url); + sendBase("parseURLs", args); + } - public OnlineCheck recv_checkOnlineStatus() throws org.apache.thrift.TException - { - checkOnlineStatus_result result = new checkOnlineStatus_result(); - receiveBase(result, "checkOnlineStatus"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkOnlineStatus failed: unknown result"); - } + public Map<String, List<String>> recv_parseURLs() throws org.apache.thrift.TException { + parseURLs_result result = new parseURLs_result(); + receiveBase(result, "parseURLs"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "parseURLs failed: unknown result"); + } - public OnlineCheck checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException - { - send_checkOnlineStatusContainer(urls, filename, data); - return recv_checkOnlineStatusContainer(); - } + public OnlineCheck checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException { + send_checkOnlineStatus(urls); + return recv_checkOnlineStatus(); + } - public void send_checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException - { - checkOnlineStatusContainer_args args = new checkOnlineStatusContainer_args(); - args.setUrls(urls); - args.setFilename(filename); - args.setData(data); - sendBase("checkOnlineStatusContainer", args); - } + public void send_checkOnlineStatus(List<String> urls) throws org.apache.thrift.TException { + checkOnlineStatus_args args = new checkOnlineStatus_args(); + args.setUrls(urls); + sendBase("checkOnlineStatus", args); + } - public OnlineCheck recv_checkOnlineStatusContainer() throws org.apache.thrift.TException - { - checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); - receiveBase(result, "checkOnlineStatusContainer"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkOnlineStatusContainer failed: unknown result"); - } + public OnlineCheck recv_checkOnlineStatus() throws org.apache.thrift.TException { + checkOnlineStatus_result result = new checkOnlineStatus_result(); + receiveBase(result, "checkOnlineStatus"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkOnlineStatus failed: unknown result"); + } - public OnlineCheck pollResults(int rid) throws org.apache.thrift.TException - { - send_pollResults(rid); - return recv_pollResults(); - } + public OnlineCheck checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException { + send_checkOnlineStatusContainer(urls, filename, data); + return recv_checkOnlineStatusContainer(); + } - public void send_pollResults(int rid) throws org.apache.thrift.TException - { - pollResults_args args = new pollResults_args(); - args.setRid(rid); - sendBase("pollResults", args); - } + public void send_checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data) throws org.apache.thrift.TException { + checkOnlineStatusContainer_args args = new checkOnlineStatusContainer_args(); + args.setUrls(urls); + args.setFilename(filename); + args.setData(data); + sendBase("checkOnlineStatusContainer", args); + } - public OnlineCheck recv_pollResults() throws org.apache.thrift.TException - { - pollResults_result result = new pollResults_result(); - receiveBase(result, "pollResults"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "pollResults failed: unknown result"); - } + public OnlineCheck recv_checkOnlineStatusContainer() throws org.apache.thrift.TException { + checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); + receiveBase(result, "checkOnlineStatusContainer"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "checkOnlineStatusContainer failed: unknown result"); + } - public List<DownloadInfo> statusDownloads() throws org.apache.thrift.TException - { - send_statusDownloads(); - return recv_statusDownloads(); - } + public OnlineCheck pollResults(int rid) throws org.apache.thrift.TException { + send_pollResults(rid); + return recv_pollResults(); + } - public void send_statusDownloads() throws org.apache.thrift.TException - { - statusDownloads_args args = new statusDownloads_args(); - sendBase("statusDownloads", args); - } + public void send_pollResults(int rid) throws org.apache.thrift.TException { + pollResults_args args = new pollResults_args(); + args.setRid(rid); + sendBase("pollResults", args); + } - public List<DownloadInfo> recv_statusDownloads() throws org.apache.thrift.TException - { - statusDownloads_result result = new statusDownloads_result(); - receiveBase(result, "statusDownloads"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "statusDownloads failed: unknown result"); - } + public OnlineCheck recv_pollResults() throws org.apache.thrift.TException { + pollResults_result result = new pollResults_result(); + receiveBase(result, "pollResults"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "pollResults failed: unknown result"); + } - public PackageData getPackageData(int pid) throws PackageDoesNotExists, org.apache.thrift.TException - { - send_getPackageData(pid); - return recv_getPackageData(); - } + public List<DownloadInfo> statusDownloads() throws org.apache.thrift.TException { + send_statusDownloads(); + return recv_statusDownloads(); + } - public void send_getPackageData(int pid) throws org.apache.thrift.TException - { - getPackageData_args args = new getPackageData_args(); - args.setPid(pid); - sendBase("getPackageData", args); - } + public void send_statusDownloads() throws org.apache.thrift.TException { + statusDownloads_args args = new statusDownloads_args(); + sendBase("statusDownloads", args); + } - public PackageData recv_getPackageData() throws PackageDoesNotExists, org.apache.thrift.TException - { - getPackageData_result result = new getPackageData_result(); - receiveBase(result, "getPackageData"); - if (result.isSetSuccess()) { - return result.success; - } - if (result.e != null) { - throw result.e; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageData failed: unknown result"); - } + public List<DownloadInfo> recv_statusDownloads() throws org.apache.thrift.TException { + statusDownloads_result result = new statusDownloads_result(); + receiveBase(result, "statusDownloads"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "statusDownloads failed: unknown result"); + } - public PackageData getPackageInfo(int pid) throws PackageDoesNotExists, org.apache.thrift.TException - { - send_getPackageInfo(pid); - return recv_getPackageInfo(); - } + public PackageData getPackageData(int pid) throws PackageDoesNotExists, org.apache.thrift.TException { + send_getPackageData(pid); + return recv_getPackageData(); + } - public void send_getPackageInfo(int pid) throws org.apache.thrift.TException - { - getPackageInfo_args args = new getPackageInfo_args(); - args.setPid(pid); - sendBase("getPackageInfo", args); - } + public void send_getPackageData(int pid) throws org.apache.thrift.TException { + getPackageData_args args = new getPackageData_args(); + args.setPid(pid); + sendBase("getPackageData", args); + } - public PackageData recv_getPackageInfo() throws PackageDoesNotExists, org.apache.thrift.TException - { - getPackageInfo_result result = new getPackageInfo_result(); - receiveBase(result, "getPackageInfo"); - if (result.isSetSuccess()) { - return result.success; - } - if (result.e != null) { - throw result.e; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result"); - } + public PackageData recv_getPackageData() throws PackageDoesNotExists, org.apache.thrift.TException { + getPackageData_result result = new getPackageData_result(); + receiveBase(result, "getPackageData"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.e != null) { + throw result.e; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageData failed: unknown result"); + } - public FileData getFileData(int fid) throws FileDoesNotExists, org.apache.thrift.TException - { - send_getFileData(fid); - return recv_getFileData(); - } + public PackageData getPackageInfo(int pid) throws PackageDoesNotExists, org.apache.thrift.TException { + send_getPackageInfo(pid); + return recv_getPackageInfo(); + } - public void send_getFileData(int fid) throws org.apache.thrift.TException - { - getFileData_args args = new getFileData_args(); - args.setFid(fid); - sendBase("getFileData", args); - } + public void send_getPackageInfo(int pid) throws org.apache.thrift.TException { + getPackageInfo_args args = new getPackageInfo_args(); + args.setPid(pid); + sendBase("getPackageInfo", args); + } - public FileData recv_getFileData() throws FileDoesNotExists, org.apache.thrift.TException - { - getFileData_result result = new getFileData_result(); - receiveBase(result, "getFileData"); - if (result.isSetSuccess()) { - return result.success; - } - if (result.e != null) { - throw result.e; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getFileData failed: unknown result"); - } + public PackageData recv_getPackageInfo() throws PackageDoesNotExists, org.apache.thrift.TException { + getPackageInfo_result result = new getPackageInfo_result(); + receiveBase(result, "getPackageInfo"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.e != null) { + throw result.e; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageInfo failed: unknown result"); + } - public List<PackageData> getQueue() throws org.apache.thrift.TException - { - send_getQueue(); - return recv_getQueue(); - } + public FileData getFileData(int fid) throws FileDoesNotExists, org.apache.thrift.TException { + send_getFileData(fid); + return recv_getFileData(); + } - public void send_getQueue() throws org.apache.thrift.TException - { - getQueue_args args = new getQueue_args(); - sendBase("getQueue", args); - } + public void send_getFileData(int fid) throws org.apache.thrift.TException { + getFileData_args args = new getFileData_args(); + args.setFid(fid); + sendBase("getFileData", args); + } - public List<PackageData> recv_getQueue() throws org.apache.thrift.TException - { - getQueue_result result = new getQueue_result(); - receiveBase(result, "getQueue"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getQueue failed: unknown result"); - } + public FileData recv_getFileData() throws FileDoesNotExists, org.apache.thrift.TException { + getFileData_result result = new getFileData_result(); + receiveBase(result, "getFileData"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.e != null) { + throw result.e; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getFileData failed: unknown result"); + } - public List<PackageData> getCollector() throws org.apache.thrift.TException - { - send_getCollector(); - return recv_getCollector(); - } + public List<PackageData> getQueue() throws org.apache.thrift.TException { + send_getQueue(); + return recv_getQueue(); + } - public void send_getCollector() throws org.apache.thrift.TException - { - getCollector_args args = new getCollector_args(); - sendBase("getCollector", args); - } + public void send_getQueue() throws org.apache.thrift.TException { + getQueue_args args = new getQueue_args(); + sendBase("getQueue", args); + } - public List<PackageData> recv_getCollector() throws org.apache.thrift.TException - { - getCollector_result result = new getCollector_result(); - receiveBase(result, "getCollector"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCollector failed: unknown result"); - } + public List<PackageData> recv_getQueue() throws org.apache.thrift.TException { + getQueue_result result = new getQueue_result(); + receiveBase(result, "getQueue"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getQueue failed: unknown result"); + } - public List<PackageData> getQueueData() throws org.apache.thrift.TException - { - send_getQueueData(); - return recv_getQueueData(); - } + public List<PackageData> getCollector() throws org.apache.thrift.TException { + send_getCollector(); + return recv_getCollector(); + } - public void send_getQueueData() throws org.apache.thrift.TException - { - getQueueData_args args = new getQueueData_args(); - sendBase("getQueueData", args); - } + public void send_getCollector() throws org.apache.thrift.TException { + getCollector_args args = new getCollector_args(); + sendBase("getCollector", args); + } - public List<PackageData> recv_getQueueData() throws org.apache.thrift.TException - { - getQueueData_result result = new getQueueData_result(); - receiveBase(result, "getQueueData"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getQueueData failed: unknown result"); - } + public List<PackageData> recv_getCollector() throws org.apache.thrift.TException { + getCollector_result result = new getCollector_result(); + receiveBase(result, "getCollector"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCollector failed: unknown result"); + } - public List<PackageData> getCollectorData() throws org.apache.thrift.TException - { - send_getCollectorData(); - return recv_getCollectorData(); - } + public List<PackageData> getQueueData() throws org.apache.thrift.TException { + send_getQueueData(); + return recv_getQueueData(); + } - public void send_getCollectorData() throws org.apache.thrift.TException - { - getCollectorData_args args = new getCollectorData_args(); - sendBase("getCollectorData", args); - } + public void send_getQueueData() throws org.apache.thrift.TException { + getQueueData_args args = new getQueueData_args(); + sendBase("getQueueData", args); + } - public List<PackageData> recv_getCollectorData() throws org.apache.thrift.TException - { - getCollectorData_result result = new getCollectorData_result(); - receiveBase(result, "getCollectorData"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCollectorData failed: unknown result"); - } + public List<PackageData> recv_getQueueData() throws org.apache.thrift.TException { + getQueueData_result result = new getQueueData_result(); + receiveBase(result, "getQueueData"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getQueueData failed: unknown result"); + } - public Map<Short,Integer> getPackageOrder(Destination destination) throws org.apache.thrift.TException - { - send_getPackageOrder(destination); - return recv_getPackageOrder(); - } + public List<PackageData> getCollectorData() throws org.apache.thrift.TException { + send_getCollectorData(); + return recv_getCollectorData(); + } - public void send_getPackageOrder(Destination destination) throws org.apache.thrift.TException - { - getPackageOrder_args args = new getPackageOrder_args(); - args.setDestination(destination); - sendBase("getPackageOrder", args); - } + public void send_getCollectorData() throws org.apache.thrift.TException { + getCollectorData_args args = new getCollectorData_args(); + sendBase("getCollectorData", args); + } - public Map<Short,Integer> recv_getPackageOrder() throws org.apache.thrift.TException - { - getPackageOrder_result result = new getPackageOrder_result(); - receiveBase(result, "getPackageOrder"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageOrder failed: unknown result"); - } + public List<PackageData> recv_getCollectorData() throws org.apache.thrift.TException { + getCollectorData_result result = new getCollectorData_result(); + receiveBase(result, "getCollectorData"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCollectorData failed: unknown result"); + } - public Map<Short,Integer> getFileOrder(int pid) throws org.apache.thrift.TException - { - send_getFileOrder(pid); - return recv_getFileOrder(); - } + public Map<Short, Integer> getPackageOrder(Destination destination) throws org.apache.thrift.TException { + send_getPackageOrder(destination); + return recv_getPackageOrder(); + } - public void send_getFileOrder(int pid) throws org.apache.thrift.TException - { - getFileOrder_args args = new getFileOrder_args(); - args.setPid(pid); - sendBase("getFileOrder", args); - } + public void send_getPackageOrder(Destination destination) throws org.apache.thrift.TException { + getPackageOrder_args args = new getPackageOrder_args(); + args.setDestination(destination); + sendBase("getPackageOrder", args); + } - public Map<Short,Integer> recv_getFileOrder() throws org.apache.thrift.TException - { - getFileOrder_result result = new getFileOrder_result(); - receiveBase(result, "getFileOrder"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getFileOrder failed: unknown result"); - } + public Map<Short, Integer> recv_getPackageOrder() throws org.apache.thrift.TException { + getPackageOrder_result result = new getPackageOrder_result(); + receiveBase(result, "getPackageOrder"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getPackageOrder failed: unknown result"); + } - public List<Integer> generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException - { - send_generateAndAddPackages(links, dest); - return recv_generateAndAddPackages(); - } + public Map<Short, Integer> getFileOrder(int pid) throws org.apache.thrift.TException { + send_getFileOrder(pid); + return recv_getFileOrder(); + } - public void send_generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException - { - generateAndAddPackages_args args = new generateAndAddPackages_args(); - args.setLinks(links); - args.setDest(dest); - sendBase("generateAndAddPackages", args); - } + public void send_getFileOrder(int pid) throws org.apache.thrift.TException { + getFileOrder_args args = new getFileOrder_args(); + args.setPid(pid); + sendBase("getFileOrder", args); + } + + public Map<Short, Integer> recv_getFileOrder() throws org.apache.thrift.TException { + getFileOrder_result result = new getFileOrder_result(); + receiveBase(result, "getFileOrder"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getFileOrder failed: unknown result"); + } + + public List<Integer> generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException { + send_generateAndAddPackages(links, dest); + return recv_generateAndAddPackages(); + } + + public void send_generateAndAddPackages(List<String> links, Destination dest) throws org.apache.thrift.TException { + generateAndAddPackages_args args = new generateAndAddPackages_args(); + args.setLinks(links); + args.setDest(dest); + sendBase("generateAndAddPackages", args); + } + + public List<Integer> recv_generateAndAddPackages() throws org.apache.thrift.TException { + generateAndAddPackages_result result = new generateAndAddPackages_result(); + receiveBase(result, "generateAndAddPackages"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result"); + } + + public int addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException { + send_addPackage(name, links, dest); + return recv_addPackage(); + } + + public void send_addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException { + addPackage_args args = new addPackage_args(); + args.setName(name); + args.setLinks(links); + args.setDest(dest); + sendBase("addPackage", args); + } + + public int recv_addPackage() throws org.apache.thrift.TException { + addPackage_result result = new addPackage_result(); + receiveBase(result, "addPackage"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "addPackage failed: unknown result"); + } + + public void addFiles(int pid, List<String> links) throws org.apache.thrift.TException { + send_addFiles(pid, links); + recv_addFiles(); + } + + public void send_addFiles(int pid, List<String> links) throws org.apache.thrift.TException { + addFiles_args args = new addFiles_args(); + args.setPid(pid); + args.setLinks(links); + sendBase("addFiles", args); + } + + public void recv_addFiles() throws org.apache.thrift.TException { + addFiles_result result = new addFiles_result(); + receiveBase(result, "addFiles"); + return; + } + + public void uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException { + send_uploadContainer(filename, data); + recv_uploadContainer(); + } + + public void send_uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException { + uploadContainer_args args = new uploadContainer_args(); + args.setFilename(filename); + args.setData(data); + sendBase("uploadContainer", args); + } + + public void recv_uploadContainer() throws org.apache.thrift.TException { + uploadContainer_result result = new uploadContainer_result(); + receiveBase(result, "uploadContainer"); + return; + } + + public void deleteFiles(List<Integer> fids) throws org.apache.thrift.TException { + send_deleteFiles(fids); + recv_deleteFiles(); + } + + public void send_deleteFiles(List<Integer> fids) throws org.apache.thrift.TException { + deleteFiles_args args = new deleteFiles_args(); + args.setFids(fids); + sendBase("deleteFiles", args); + } + + public void recv_deleteFiles() throws org.apache.thrift.TException { + deleteFiles_result result = new deleteFiles_result(); + receiveBase(result, "deleteFiles"); + return; + } + + public void deletePackages(List<Integer> pids) throws org.apache.thrift.TException { + send_deletePackages(pids); + recv_deletePackages(); + } + + public void send_deletePackages(List<Integer> pids) throws org.apache.thrift.TException { + deletePackages_args args = new deletePackages_args(); + args.setPids(pids); + sendBase("deletePackages", args); + } + + public void recv_deletePackages() throws org.apache.thrift.TException { + deletePackages_result result = new deletePackages_result(); + receiveBase(result, "deletePackages"); + return; + } + + public void pushToQueue(int pid) throws org.apache.thrift.TException { + send_pushToQueue(pid); + recv_pushToQueue(); + } + + public void send_pushToQueue(int pid) throws org.apache.thrift.TException { + pushToQueue_args args = new pushToQueue_args(); + args.setPid(pid); + sendBase("pushToQueue", args); + } + + public void recv_pushToQueue() throws org.apache.thrift.TException { + pushToQueue_result result = new pushToQueue_result(); + receiveBase(result, "pushToQueue"); + return; + } + + public void pullFromQueue(int pid) throws org.apache.thrift.TException { + send_pullFromQueue(pid); + recv_pullFromQueue(); + } + + public void send_pullFromQueue(int pid) throws org.apache.thrift.TException { + pullFromQueue_args args = new pullFromQueue_args(); + args.setPid(pid); + sendBase("pullFromQueue", args); + } + + public void recv_pullFromQueue() throws org.apache.thrift.TException { + pullFromQueue_result result = new pullFromQueue_result(); + receiveBase(result, "pullFromQueue"); + return; + } + + public void restartPackage(int pid) throws org.apache.thrift.TException { + send_restartPackage(pid); + recv_restartPackage(); + } + + public void send_restartPackage(int pid) throws org.apache.thrift.TException { + restartPackage_args args = new restartPackage_args(); + args.setPid(pid); + sendBase("restartPackage", args); + } + + public void recv_restartPackage() throws org.apache.thrift.TException { + restartPackage_result result = new restartPackage_result(); + receiveBase(result, "restartPackage"); + return; + } + + public void restartFile(int fid) throws org.apache.thrift.TException { + send_restartFile(fid); + recv_restartFile(); + } + + public void send_restartFile(int fid) throws org.apache.thrift.TException { + restartFile_args args = new restartFile_args(); + args.setFid(fid); + sendBase("restartFile", args); + } + + public void recv_restartFile() throws org.apache.thrift.TException { + restartFile_result result = new restartFile_result(); + receiveBase(result, "restartFile"); + return; + } + + public void recheckPackage(int pid) throws org.apache.thrift.TException { + send_recheckPackage(pid); + recv_recheckPackage(); + } + + public void send_recheckPackage(int pid) throws org.apache.thrift.TException { + recheckPackage_args args = new recheckPackage_args(); + args.setPid(pid); + sendBase("recheckPackage", args); + } + + public void recv_recheckPackage() throws org.apache.thrift.TException { + recheckPackage_result result = new recheckPackage_result(); + receiveBase(result, "recheckPackage"); + return; + } + + public void stopAllDownloads() throws org.apache.thrift.TException { + send_stopAllDownloads(); + recv_stopAllDownloads(); + } + + public void send_stopAllDownloads() throws org.apache.thrift.TException { + stopAllDownloads_args args = new stopAllDownloads_args(); + sendBase("stopAllDownloads", args); + } + + public void recv_stopAllDownloads() throws org.apache.thrift.TException { + stopAllDownloads_result result = new stopAllDownloads_result(); + receiveBase(result, "stopAllDownloads"); + return; + } + + public void stopDownloads(List<Integer> fids) throws org.apache.thrift.TException { + send_stopDownloads(fids); + recv_stopDownloads(); + } + + public void send_stopDownloads(List<Integer> fids) throws org.apache.thrift.TException { + stopDownloads_args args = new stopDownloads_args(); + args.setFids(fids); + sendBase("stopDownloads", args); + } + + public void recv_stopDownloads() throws org.apache.thrift.TException { + stopDownloads_result result = new stopDownloads_result(); + receiveBase(result, "stopDownloads"); + return; + } + + public void setPackageName(int pid, String name) throws org.apache.thrift.TException { + send_setPackageName(pid, name); + recv_setPackageName(); + } + + public void send_setPackageName(int pid, String name) throws org.apache.thrift.TException { + setPackageName_args args = new setPackageName_args(); + args.setPid(pid); + args.setName(name); + sendBase("setPackageName", args); + } + + public void recv_setPackageName() throws org.apache.thrift.TException { + setPackageName_result result = new setPackageName_result(); + receiveBase(result, "setPackageName"); + return; + } + + public void movePackage(Destination destination, int pid) throws org.apache.thrift.TException { + send_movePackage(destination, pid); + recv_movePackage(); + } + + public void send_movePackage(Destination destination, int pid) throws org.apache.thrift.TException { + movePackage_args args = new movePackage_args(); + args.setDestination(destination); + args.setPid(pid); + sendBase("movePackage", args); + } + + public void recv_movePackage() throws org.apache.thrift.TException { + movePackage_result result = new movePackage_result(); + receiveBase(result, "movePackage"); + return; + } + + public void moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException { + send_moveFiles(fids, pid); + recv_moveFiles(); + } + + public void send_moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException { + moveFiles_args args = new moveFiles_args(); + args.setFids(fids); + args.setPid(pid); + sendBase("moveFiles", args); + } + + public void recv_moveFiles() throws org.apache.thrift.TException { + moveFiles_result result = new moveFiles_result(); + receiveBase(result, "moveFiles"); + return; + } + + public void orderPackage(int pid, short position) throws org.apache.thrift.TException { + send_orderPackage(pid, position); + recv_orderPackage(); + } + + public void send_orderPackage(int pid, short position) throws org.apache.thrift.TException { + orderPackage_args args = new orderPackage_args(); + args.setPid(pid); + args.setPosition(position); + sendBase("orderPackage", args); + } + + public void recv_orderPackage() throws org.apache.thrift.TException { + orderPackage_result result = new orderPackage_result(); + receiveBase(result, "orderPackage"); + return; + } + + public void orderFile(int fid, short position) throws org.apache.thrift.TException { + send_orderFile(fid, position); + recv_orderFile(); + } + + public void send_orderFile(int fid, short position) throws org.apache.thrift.TException { + orderFile_args args = new orderFile_args(); + args.setFid(fid); + args.setPosition(position); + sendBase("orderFile", args); + } + + public void recv_orderFile() throws org.apache.thrift.TException { + orderFile_result result = new orderFile_result(); + receiveBase(result, "orderFile"); + return; + } + + public void setPackageData(int pid, Map<String, String> data) throws PackageDoesNotExists, org.apache.thrift.TException { + send_setPackageData(pid, data); + recv_setPackageData(); + } + + public void send_setPackageData(int pid, Map<String, String> data) throws org.apache.thrift.TException { + setPackageData_args args = new setPackageData_args(); + args.setPid(pid); + args.setData(data); + sendBase("setPackageData", args); + } + + public void recv_setPackageData() throws PackageDoesNotExists, org.apache.thrift.TException { + setPackageData_result result = new setPackageData_result(); + receiveBase(result, "setPackageData"); + if (result.e != null) { + throw result.e; + } + return; + } + + public List<Integer> deleteFinished() throws org.apache.thrift.TException { + send_deleteFinished(); + return recv_deleteFinished(); + } + + public void send_deleteFinished() throws org.apache.thrift.TException { + deleteFinished_args args = new deleteFinished_args(); + sendBase("deleteFinished", args); + } + + public List<Integer> recv_deleteFinished() throws org.apache.thrift.TException { + deleteFinished_result result = new deleteFinished_result(); + receiveBase(result, "deleteFinished"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteFinished failed: unknown result"); + } + + public void restartFailed() throws org.apache.thrift.TException { + send_restartFailed(); + recv_restartFailed(); + } + + public void send_restartFailed() throws org.apache.thrift.TException { + restartFailed_args args = new restartFailed_args(); + sendBase("restartFailed", args); + } + + public void recv_restartFailed() throws org.apache.thrift.TException { + restartFailed_result result = new restartFailed_result(); + receiveBase(result, "restartFailed"); + return; + } + + public List<EventInfo> getEvents(String uuid) throws org.apache.thrift.TException { + send_getEvents(uuid); + return recv_getEvents(); + } + + public void send_getEvents(String uuid) throws org.apache.thrift.TException { + getEvents_args args = new getEvents_args(); + args.setUuid(uuid); + sendBase("getEvents", args); + } + + public List<EventInfo> recv_getEvents() throws org.apache.thrift.TException { + getEvents_result result = new getEvents_result(); + receiveBase(result, "getEvents"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getEvents failed: unknown result"); + } + + public List<AccountInfo> getAccounts(boolean refresh) throws org.apache.thrift.TException { + send_getAccounts(refresh); + return recv_getAccounts(); + } + + public void send_getAccounts(boolean refresh) throws org.apache.thrift.TException { + getAccounts_args args = new getAccounts_args(); + args.setRefresh(refresh); + sendBase("getAccounts", args); + } + + public List<AccountInfo> recv_getAccounts() throws org.apache.thrift.TException { + getAccounts_result result = new getAccounts_result(); + receiveBase(result, "getAccounts"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAccounts failed: unknown result"); + } + + public List<String> getAccountTypes() throws org.apache.thrift.TException { + send_getAccountTypes(); + return recv_getAccountTypes(); + } + + public void send_getAccountTypes() throws org.apache.thrift.TException { + getAccountTypes_args args = new getAccountTypes_args(); + sendBase("getAccountTypes", args); + } + + public List<String> recv_getAccountTypes() throws org.apache.thrift.TException { + getAccountTypes_result result = new getAccountTypes_result(); + receiveBase(result, "getAccountTypes"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAccountTypes failed: unknown result"); + } + + public void updateAccount(String plugin, String account, String password, Map<String, String> options) throws org.apache.thrift.TException { + send_updateAccount(plugin, account, password, options); + recv_updateAccount(); + } + + public void send_updateAccount(String plugin, String account, String password, Map<String, String> options) throws org.apache.thrift.TException { + updateAccount_args args = new updateAccount_args(); + args.setPlugin(plugin); + args.setAccount(account); + args.setPassword(password); + args.setOptions(options); + sendBase("updateAccount", args); + } + + public void recv_updateAccount() throws org.apache.thrift.TException { + updateAccount_result result = new updateAccount_result(); + receiveBase(result, "updateAccount"); + return; + } + + public void removeAccount(String plugin, String account) throws org.apache.thrift.TException { + send_removeAccount(plugin, account); + recv_removeAccount(); + } + + public void send_removeAccount(String plugin, String account) throws org.apache.thrift.TException { + removeAccount_args args = new removeAccount_args(); + args.setPlugin(plugin); + args.setAccount(account); + sendBase("removeAccount", args); + } + + public void recv_removeAccount() throws org.apache.thrift.TException { + removeAccount_result result = new removeAccount_result(); + receiveBase(result, "removeAccount"); + return; + } + + public boolean login(String username, String password) throws org.apache.thrift.TException { + send_login(username, password); + return recv_login(); + } + + public void send_login(String username, String password) throws org.apache.thrift.TException { + login_args args = new login_args(); + args.setUsername(username); + args.setPassword(password); + sendBase("login", args); + } + + public boolean recv_login() throws org.apache.thrift.TException { + login_result result = new login_result(); + receiveBase(result, "login"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "login failed: unknown result"); + } + + public UserData getUserData(String username, String password) throws org.apache.thrift.TException { + send_getUserData(username, password); + return recv_getUserData(); + } + + public void send_getUserData(String username, String password) throws org.apache.thrift.TException { + getUserData_args args = new getUserData_args(); + args.setUsername(username); + args.setPassword(password); + sendBase("getUserData", args); + } + + public UserData recv_getUserData() throws org.apache.thrift.TException { + getUserData_result result = new getUserData_result(); + receiveBase(result, "getUserData"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserData failed: unknown result"); + } + + public Map<String, UserData> getAllUserData() throws org.apache.thrift.TException { + send_getAllUserData(); + return recv_getAllUserData(); + } + + public void send_getAllUserData() throws org.apache.thrift.TException { + getAllUserData_args args = new getAllUserData_args(); + sendBase("getAllUserData", args); + } + + public Map<String, UserData> recv_getAllUserData() throws org.apache.thrift.TException { + getAllUserData_result result = new getAllUserData_result(); + receiveBase(result, "getAllUserData"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllUserData failed: unknown result"); + } + + public Map<String, Map<String, String>> getServices() throws org.apache.thrift.TException { + send_getServices(); + return recv_getServices(); + } + + public void send_getServices() throws org.apache.thrift.TException { + getServices_args args = new getServices_args(); + sendBase("getServices", args); + } + + public Map<String, Map<String, String>> recv_getServices() throws org.apache.thrift.TException { + getServices_result result = new getServices_result(); + receiveBase(result, "getServices"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getServices failed: unknown result"); + } + + public boolean hasService(String plugin, String func) throws org.apache.thrift.TException { + send_hasService(plugin, func); + return recv_hasService(); + } + + public void send_hasService(String plugin, String func) throws org.apache.thrift.TException { + hasService_args args = new hasService_args(); + args.setPlugin(plugin); + args.setFunc(func); + sendBase("hasService", args); + } + + public boolean recv_hasService() throws org.apache.thrift.TException { + hasService_result result = new hasService_result(); + receiveBase(result, "hasService"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "hasService failed: unknown result"); + } + + public String call(ServiceCall info) throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException { + send_call(info); + return recv_call(); + } + + public void send_call(ServiceCall info) throws org.apache.thrift.TException { + call_args args = new call_args(); + args.setInfo(info); + sendBase("call", args); + } + + public String recv_call() throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException { + call_result result = new call_result(); + receiveBase(result, "call"); + if (result.isSetSuccess()) { + return result.success; + } + if (result.ex != null) { + throw result.ex; + } + if (result.e != null) { + throw result.e; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "call failed: unknown result"); + } + + public Map<String, Map<String, String>> getAllInfo() throws org.apache.thrift.TException { + send_getAllInfo(); + return recv_getAllInfo(); + } + + public void send_getAllInfo() throws org.apache.thrift.TException { + getAllInfo_args args = new getAllInfo_args(); + sendBase("getAllInfo", args); + } + + public Map<String, Map<String, String>> recv_getAllInfo() throws org.apache.thrift.TException { + getAllInfo_result result = new getAllInfo_result(); + receiveBase(result, "getAllInfo"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllInfo failed: unknown result"); + } + + public Map<String, String> getInfoByPlugin(String plugin) throws org.apache.thrift.TException { + send_getInfoByPlugin(plugin); + return recv_getInfoByPlugin(); + } + + public void send_getInfoByPlugin(String plugin) throws org.apache.thrift.TException { + getInfoByPlugin_args args = new getInfoByPlugin_args(); + args.setPlugin(plugin); + sendBase("getInfoByPlugin", args); + } + + public Map<String, String> recv_getInfoByPlugin() throws org.apache.thrift.TException { + getInfoByPlugin_result result = new getInfoByPlugin_result(); + receiveBase(result, "getInfoByPlugin"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getInfoByPlugin failed: unknown result"); + } + + public boolean isCaptchaWaiting() throws org.apache.thrift.TException { + send_isCaptchaWaiting(); + return recv_isCaptchaWaiting(); + } + + public void send_isCaptchaWaiting() throws org.apache.thrift.TException { + isCaptchaWaiting_args args = new isCaptchaWaiting_args(); + sendBase("isCaptchaWaiting", args); + } + + public boolean recv_isCaptchaWaiting() throws org.apache.thrift.TException { + isCaptchaWaiting_result result = new isCaptchaWaiting_result(); + receiveBase(result, "isCaptchaWaiting"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isCaptchaWaiting failed: unknown result"); + } + + public CaptchaTask getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException { + send_getCaptchaTask(exclusive); + return recv_getCaptchaTask(); + } + + public void send_getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException { + getCaptchaTask_args args = new getCaptchaTask_args(); + args.setExclusive(exclusive); + sendBase("getCaptchaTask", args); + } + + public CaptchaTask recv_getCaptchaTask() throws org.apache.thrift.TException { + getCaptchaTask_result result = new getCaptchaTask_result(); + receiveBase(result, "getCaptchaTask"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCaptchaTask failed: unknown result"); + } + + public String getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException { + send_getCaptchaTaskStatus(tid); + return recv_getCaptchaTaskStatus(); + } + + public void send_getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException { + getCaptchaTaskStatus_args args = new getCaptchaTaskStatus_args(); + args.setTid(tid); + sendBase("getCaptchaTaskStatus", args); + } + + public String recv_getCaptchaTaskStatus() throws org.apache.thrift.TException { + getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); + receiveBase(result, "getCaptchaTaskStatus"); + if (result.isSetSuccess()) { + return result.success; + } + throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCaptchaTaskStatus failed: unknown result"); + } + + public void setCaptchaResult(int tid, String result) throws org.apache.thrift.TException { + send_setCaptchaResult(tid, result); + recv_setCaptchaResult(); + } + + public void send_setCaptchaResult(int tid, String result) throws org.apache.thrift.TException { + setCaptchaResult_args args = new setCaptchaResult_args(); + args.setTid(tid); + args.setResult(result); + sendBase("setCaptchaResult", args); + } + + public void recv_setCaptchaResult() throws org.apache.thrift.TException { + setCaptchaResult_result result = new setCaptchaResult_result(); + receiveBase(result, "setCaptchaResult"); + return; + } + + } + + 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 getConfigValue(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getConfigValue_call method_call = new getConfigValue_call(category, option, section, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getConfigValue_call extends org.apache.thrift.async.TAsyncMethodCall { + private String category; + private String option; + private String section; + + public getConfigValue_call(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.category = category; + this.option = option; + this.section = section; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getConfigValue", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getConfigValue_args args = new getConfigValue_args(); + args.setCategory(category); + args.setOption(option); + args.setSection(section); + args.write(prot); + prot.writeMessageEnd(); + } + + public String getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getConfigValue(); + } + } + + public void setConfigValue(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + setConfigValue_call method_call = new setConfigValue_call(category, option, value, section, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class setConfigValue_call extends org.apache.thrift.async.TAsyncMethodCall { + private String category; + private String option; + private String value; + private String section; + + public setConfigValue_call(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.category = category; + this.option = option; + this.value = value; + this.section = section; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setConfigValue", org.apache.thrift.protocol.TMessageType.CALL, 0)); + setConfigValue_args args = new setConfigValue_args(); + args.setCategory(category); + args.setOption(option); + args.setValue(value); + args.setSection(section); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_setConfigValue(); + } + } + + public void getConfig(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getConfig_call method_call = new getConfig_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getConfig_call extends org.apache.thrift.async.TAsyncMethodCall { + public getConfig_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getConfig", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getConfig_args args = new getConfig_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, ConfigSection> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getConfig(); + } + } + + public void getPluginConfig(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getPluginConfig_call method_call = new getPluginConfig_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getPluginConfig_call extends org.apache.thrift.async.TAsyncMethodCall { + public getPluginConfig_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPluginConfig", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getPluginConfig_args args = new getPluginConfig_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, ConfigSection> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getPluginConfig(); + } + } + + public void pauseServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + pauseServer_call method_call = new pauseServer_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class pauseServer_call extends org.apache.thrift.async.TAsyncMethodCall { + public pauseServer_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pauseServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + pauseServer_args args = new pauseServer_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_pauseServer(); + } + } + + public void unpauseServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + unpauseServer_call method_call = new unpauseServer_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class unpauseServer_call extends org.apache.thrift.async.TAsyncMethodCall { + public unpauseServer_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("unpauseServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + unpauseServer_args args = new unpauseServer_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_unpauseServer(); + } + } + + public void togglePause(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + togglePause_call method_call = new togglePause_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class togglePause_call extends org.apache.thrift.async.TAsyncMethodCall { + public togglePause_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("togglePause", org.apache.thrift.protocol.TMessageType.CALL, 0)); + togglePause_args args = new togglePause_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_togglePause(); + } + } + + public void statusServer(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + statusServer_call method_call = new statusServer_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class statusServer_call extends org.apache.thrift.async.TAsyncMethodCall { + public statusServer_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("statusServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + statusServer_args args = new statusServer_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public ServerStatus getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_statusServer(); + } + } + + public void freeSpace(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + freeSpace_call method_call = new freeSpace_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class freeSpace_call extends org.apache.thrift.async.TAsyncMethodCall { + public freeSpace_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("freeSpace", org.apache.thrift.protocol.TMessageType.CALL, 0)); + freeSpace_args args = new freeSpace_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public long getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_freeSpace(); + } + } + + public void getServerVersion(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getServerVersion_call method_call = new getServerVersion_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getServerVersion_call extends org.apache.thrift.async.TAsyncMethodCall { + public getServerVersion_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getServerVersion", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getServerVersion_args args = new getServerVersion_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public String getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getServerVersion(); + } + } + + public void kill(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + kill_call method_call = new kill_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class kill_call extends org.apache.thrift.async.TAsyncMethodCall { + public kill_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("kill", org.apache.thrift.protocol.TMessageType.CALL, 0)); + kill_args args = new kill_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_kill(); + } + } + + public void restart(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + restart_call method_call = new restart_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class restart_call extends org.apache.thrift.async.TAsyncMethodCall { + public restart_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restart", org.apache.thrift.protocol.TMessageType.CALL, 0)); + restart_args args = new restart_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_restart(); + } + } + + public void getLog(int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getLog_call method_call = new getLog_call(offset, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getLog_call extends org.apache.thrift.async.TAsyncMethodCall { + private int offset; + + public getLog_call(int offset, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.offset = offset; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLog", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getLog_args args = new getLog_args(); + args.setOffset(offset); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<String> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getLog(); + } + } + + public void isTimeDownload(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + isTimeDownload_call method_call = new isTimeDownload_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class isTimeDownload_call extends org.apache.thrift.async.TAsyncMethodCall { + public isTimeDownload_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTimeDownload", org.apache.thrift.protocol.TMessageType.CALL, 0)); + isTimeDownload_args args = new isTimeDownload_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_isTimeDownload(); + } + } + + public void isTimeReconnect(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + isTimeReconnect_call method_call = new isTimeReconnect_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class isTimeReconnect_call extends org.apache.thrift.async.TAsyncMethodCall { + public isTimeReconnect_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isTimeReconnect", org.apache.thrift.protocol.TMessageType.CALL, 0)); + isTimeReconnect_args args = new isTimeReconnect_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_isTimeReconnect(); + } + } + + public void toggleReconnect(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + toggleReconnect_call method_call = new toggleReconnect_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class toggleReconnect_call extends org.apache.thrift.async.TAsyncMethodCall { + public toggleReconnect_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("toggleReconnect", org.apache.thrift.protocol.TMessageType.CALL, 0)); + toggleReconnect_args args = new toggleReconnect_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_toggleReconnect(); + } + } + + public void generatePackages(List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + generatePackages_call method_call = new generatePackages_call(links, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class generatePackages_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<String> links; + + public generatePackages_call(List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.links = links; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("generatePackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); + generatePackages_args args = new generatePackages_args(); + args.setLinks(links); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, List<String>> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_generatePackages(); + } + } + + public void checkURLs(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + checkURLs_call method_call = new checkURLs_call(urls, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class checkURLs_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<String> urls; + + public checkURLs_call(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.urls = urls; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkURLs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + checkURLs_args args = new checkURLs_args(); + args.setUrls(urls); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, List<String>> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_checkURLs(); + } + } + + public void parseURLs(String html, String url, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + parseURLs_call method_call = new parseURLs_call(html, url, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class parseURLs_call extends org.apache.thrift.async.TAsyncMethodCall { + private String html; + private String url; + + public parseURLs_call(String html, String url, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.html = html; + this.url = url; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("parseURLs", org.apache.thrift.protocol.TMessageType.CALL, 0)); + parseURLs_args args = new parseURLs_args(); + args.setHtml(html); + args.setUrl(url); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, List<String>> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_parseURLs(); + } + } + + public void checkOnlineStatus(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + checkOnlineStatus_call method_call = new checkOnlineStatus_call(urls, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class checkOnlineStatus_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<String> urls; + + public checkOnlineStatus_call(List<String> urls, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.urls = urls; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkOnlineStatus", org.apache.thrift.protocol.TMessageType.CALL, 0)); + checkOnlineStatus_args args = new checkOnlineStatus_args(); + args.setUrls(urls); + args.write(prot); + prot.writeMessageEnd(); + } + + public OnlineCheck getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_checkOnlineStatus(); + } + } + + public void checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + checkOnlineStatusContainer_call method_call = new checkOnlineStatusContainer_call(urls, filename, data, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class checkOnlineStatusContainer_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<String> urls; + private String filename; + private ByteBuffer data; + + public checkOnlineStatusContainer_call(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.urls = urls; + this.filename = filename; + this.data = data; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkOnlineStatusContainer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + checkOnlineStatusContainer_args args = new checkOnlineStatusContainer_args(); + args.setUrls(urls); + args.setFilename(filename); + args.setData(data); + args.write(prot); + prot.writeMessageEnd(); + } + + public OnlineCheck getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_checkOnlineStatusContainer(); + } + } + + public void pollResults(int rid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + pollResults_call method_call = new pollResults_call(rid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class pollResults_call extends org.apache.thrift.async.TAsyncMethodCall { + private int rid; + + public pollResults_call(int rid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.rid = rid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pollResults", org.apache.thrift.protocol.TMessageType.CALL, 0)); + pollResults_args args = new pollResults_args(); + args.setRid(rid); + args.write(prot); + prot.writeMessageEnd(); + } + + public OnlineCheck getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_pollResults(); + } + } + + public void statusDownloads(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + statusDownloads_call method_call = new statusDownloads_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class statusDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { + public statusDownloads_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("statusDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); + statusDownloads_args args = new statusDownloads_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<DownloadInfo> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_statusDownloads(); + } + } + + public void getPackageData(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getPackageData_call method_call = new getPackageData_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getPackageData_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public getPackageData_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getPackageData_args args = new getPackageData_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public PackageData getResult() throws PackageDoesNotExists, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getPackageData(); + } + } + + public void getPackageInfo(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getPackageInfo_call method_call = new getPackageInfo_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getPackageInfo_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public getPackageInfo_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageInfo", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getPackageInfo_args args = new getPackageInfo_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public PackageData getResult() throws PackageDoesNotExists, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getPackageInfo(); + } + } + + public void getFileData(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getFileData_call method_call = new getFileData_call(fid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getFileData_call extends org.apache.thrift.async.TAsyncMethodCall { + private int fid; + + public getFileData_call(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fid = fid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getFileData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getFileData_args args = new getFileData_args(); + args.setFid(fid); + args.write(prot); + prot.writeMessageEnd(); + } + + public FileData getResult() throws FileDoesNotExists, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getFileData(); + } + } + + public void getQueue(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getQueue_call method_call = new getQueue_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getQueue_call extends org.apache.thrift.async.TAsyncMethodCall { + public getQueue_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getQueue_args args = new getQueue_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<PackageData> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getQueue(); + } + } + + public void getCollector(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getCollector_call method_call = new getCollector_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getCollector_call extends org.apache.thrift.async.TAsyncMethodCall { + public getCollector_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCollector", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getCollector_args args = new getCollector_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<PackageData> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getCollector(); + } + } + + public void getQueueData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getQueueData_call method_call = new getQueueData_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getQueueData_call extends org.apache.thrift.async.TAsyncMethodCall { + public getQueueData_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getQueueData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getQueueData_args args = new getQueueData_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<PackageData> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getQueueData(); + } + } + + public void getCollectorData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getCollectorData_call method_call = new getCollectorData_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getCollectorData_call extends org.apache.thrift.async.TAsyncMethodCall { + public getCollectorData_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCollectorData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getCollectorData_args args = new getCollectorData_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<PackageData> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getCollectorData(); + } + } + + public void getPackageOrder(Destination destination, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getPackageOrder_call method_call = new getPackageOrder_call(destination, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getPackageOrder_call extends org.apache.thrift.async.TAsyncMethodCall { + private Destination destination; + + public getPackageOrder_call(Destination destination, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.destination = destination; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageOrder", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getPackageOrder_args args = new getPackageOrder_args(); + args.setDestination(destination); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<Short, Integer> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getPackageOrder(); + } + } + + public void getFileOrder(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getFileOrder_call method_call = new getFileOrder_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getFileOrder_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public getFileOrder_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getFileOrder", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getFileOrder_args args = new getFileOrder_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<Short, Integer> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getFileOrder(); + } + } + + public void generateAndAddPackages(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + generateAndAddPackages_call method_call = new generateAndAddPackages_call(links, dest, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class generateAndAddPackages_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<String> links; + private Destination dest; + + public generateAndAddPackages_call(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.links = links; + this.dest = dest; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("generateAndAddPackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); + generateAndAddPackages_args args = new generateAndAddPackages_args(); + args.setLinks(links); + args.setDest(dest); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<Integer> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_generateAndAddPackages(); + } + } + + public void addPackage(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + addPackage_call method_call = new addPackage_call(name, links, dest, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class addPackage_call extends org.apache.thrift.async.TAsyncMethodCall { + private String name; + private List<String> links; + private Destination dest; + + public addPackage_call(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.name = name; + this.links = links; + this.dest = dest; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + addPackage_args args = new addPackage_args(); + args.setName(name); + args.setLinks(links); + args.setDest(dest); + args.write(prot); + prot.writeMessageEnd(); + } + + public int getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_addPackage(); + } + } + + public void addFiles(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + addFiles_call method_call = new addFiles_call(pid, links, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class addFiles_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + private List<String> links; + + public addFiles_call(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + this.links = links; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); + addFiles_args args = new addFiles_args(); + args.setPid(pid); + args.setLinks(links); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_addFiles(); + } + } + + public void uploadContainer(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + uploadContainer_call method_call = new uploadContainer_call(filename, data, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class uploadContainer_call extends org.apache.thrift.async.TAsyncMethodCall { + private String filename; + private ByteBuffer data; + + public uploadContainer_call(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.filename = filename; + this.data = data; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("uploadContainer", org.apache.thrift.protocol.TMessageType.CALL, 0)); + uploadContainer_args args = new uploadContainer_args(); + args.setFilename(filename); + args.setData(data); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_uploadContainer(); + } + } + + public void deleteFiles(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + deleteFiles_call method_call = new deleteFiles_call(fids, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class deleteFiles_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<Integer> fids; + + public deleteFiles_call(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fids = fids; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); + deleteFiles_args args = new deleteFiles_args(); + args.setFids(fids); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_deleteFiles(); + } + } + + public void deletePackages(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + deletePackages_call method_call = new deletePackages_call(pids, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class deletePackages_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<Integer> pids; + + public deletePackages_call(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pids = pids; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deletePackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); + deletePackages_args args = new deletePackages_args(); + args.setPids(pids); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_deletePackages(); + } + } + + public void pushToQueue(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + pushToQueue_call method_call = new pushToQueue_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class pushToQueue_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public pushToQueue_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pushToQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); + pushToQueue_args args = new pushToQueue_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_pushToQueue(); + } + } + + public void pullFromQueue(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + pullFromQueue_call method_call = new pullFromQueue_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class pullFromQueue_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public pullFromQueue_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pullFromQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); + pullFromQueue_args args = new pullFromQueue_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_pullFromQueue(); + } + } + + public void restartPackage(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + restartPackage_call method_call = new restartPackage_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class restartPackage_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public restartPackage_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restartPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + restartPackage_args args = new restartPackage_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_restartPackage(); + } + } + + public void restartFile(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + restartFile_call method_call = new restartFile_call(fid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class restartFile_call extends org.apache.thrift.async.TAsyncMethodCall { + private int fid; + + public restartFile_call(int fid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fid = fid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restartFile", org.apache.thrift.protocol.TMessageType.CALL, 0)); + restartFile_args args = new restartFile_args(); + args.setFid(fid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_restartFile(); + } + } + + public void recheckPackage(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + recheckPackage_call method_call = new recheckPackage_call(pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class recheckPackage_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + + public recheckPackage_call(int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("recheckPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + recheckPackage_args args = new recheckPackage_args(); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_recheckPackage(); + } + } + + public void stopAllDownloads(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + stopAllDownloads_call method_call = new stopAllDownloads_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class stopAllDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { + public stopAllDownloads_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("stopAllDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); + stopAllDownloads_args args = new stopAllDownloads_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_stopAllDownloads(); + } + } + + public void stopDownloads(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + stopDownloads_call method_call = new stopDownloads_call(fids, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class stopDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<Integer> fids; + + public stopDownloads_call(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fids = fids; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("stopDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); + stopDownloads_args args = new stopDownloads_args(); + args.setFids(fids); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_stopDownloads(); + } + } + + public void setPackageName(int pid, String name, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + setPackageName_call method_call = new setPackageName_call(pid, name, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class setPackageName_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + private String name; + + public setPackageName_call(int pid, String name, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + 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("setPackageName", org.apache.thrift.protocol.TMessageType.CALL, 0)); + setPackageName_args args = new setPackageName_args(); + args.setPid(pid); + args.setName(name); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_setPackageName(); + } + } + + public void movePackage(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + movePackage_call method_call = new movePackage_call(destination, pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class movePackage_call extends org.apache.thrift.async.TAsyncMethodCall { + private Destination destination; + private int pid; + + public movePackage_call(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.destination = destination; + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("movePackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + movePackage_args args = new movePackage_args(); + args.setDestination(destination); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_movePackage(); + } + } + + public void moveFiles(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + moveFiles_call method_call = new moveFiles_call(fids, pid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class moveFiles_call extends org.apache.thrift.async.TAsyncMethodCall { + private List<Integer> fids; + private int pid; + + public moveFiles_call(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fids = fids; + this.pid = pid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("moveFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); + moveFiles_args args = new moveFiles_args(); + args.setFids(fids); + args.setPid(pid); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_moveFiles(); + } + } + + public void orderPackage(int pid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + orderPackage_call method_call = new orderPackage_call(pid, position, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class orderPackage_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + private short position; + + public orderPackage_call(int pid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + this.position = position; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("orderPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); + orderPackage_args args = new orderPackage_args(); + args.setPid(pid); + args.setPosition(position); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_orderPackage(); + } + } + + public void orderFile(int fid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + orderFile_call method_call = new orderFile_call(fid, position, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class orderFile_call extends org.apache.thrift.async.TAsyncMethodCall { + private int fid; + private short position; + + public orderFile_call(int fid, short position, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.fid = fid; + this.position = position; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("orderFile", org.apache.thrift.protocol.TMessageType.CALL, 0)); + orderFile_args args = new orderFile_args(); + args.setFid(fid); + args.setPosition(position); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_orderFile(); + } + } + + public void setPackageData(int pid, Map<String, String> data, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + setPackageData_call method_call = new setPackageData_call(pid, data, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class setPackageData_call extends org.apache.thrift.async.TAsyncMethodCall { + private int pid; + private Map<String, String> data; + + public setPackageData_call(int pid, Map<String, String> data, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.pid = pid; + this.data = data; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setPackageData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + setPackageData_args args = new setPackageData_args(); + args.setPid(pid); + args.setData(data); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws PackageDoesNotExists, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_setPackageData(); + } + } + + public void deleteFinished(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + deleteFinished_call method_call = new deleteFinished_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class deleteFinished_call extends org.apache.thrift.async.TAsyncMethodCall { + public deleteFinished_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteFinished", org.apache.thrift.protocol.TMessageType.CALL, 0)); + deleteFinished_args args = new deleteFinished_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<Integer> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_deleteFinished(); + } + } + + public void restartFailed(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + restartFailed_call method_call = new restartFailed_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class restartFailed_call extends org.apache.thrift.async.TAsyncMethodCall { + public restartFailed_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restartFailed", org.apache.thrift.protocol.TMessageType.CALL, 0)); + restartFailed_args args = new restartFailed_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_restartFailed(); + } + } + + public void getEvents(String uuid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getEvents_call method_call = new getEvents_call(uuid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getEvents_call extends org.apache.thrift.async.TAsyncMethodCall { + private String uuid; + + public getEvents_call(String uuid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.uuid = uuid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getEvents", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getEvents_args args = new getEvents_args(); + args.setUuid(uuid); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<EventInfo> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getEvents(); + } + } + + public void getAccounts(boolean refresh, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getAccounts_call method_call = new getAccounts_call(refresh, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getAccounts_call extends org.apache.thrift.async.TAsyncMethodCall { + private boolean refresh; + + public getAccounts_call(boolean refresh, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.refresh = refresh; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAccounts", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getAccounts_args args = new getAccounts_args(); + args.setRefresh(refresh); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<AccountInfo> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getAccounts(); + } + } + + public void getAccountTypes(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getAccountTypes_call method_call = new getAccountTypes_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getAccountTypes_call extends org.apache.thrift.async.TAsyncMethodCall { + public getAccountTypes_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAccountTypes", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getAccountTypes_args args = new getAccountTypes_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public List<String> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getAccountTypes(); + } + } + + public void updateAccount(String plugin, String account, String password, Map<String, String> options, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + updateAccount_call method_call = new updateAccount_call(plugin, account, password, options, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class updateAccount_call extends org.apache.thrift.async.TAsyncMethodCall { + private String plugin; + private String account; + private String password; + private Map<String, String> options; + + public updateAccount_call(String plugin, String account, String password, Map<String, String> options, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.plugin = plugin; + this.account = account; + this.password = password; + this.options = options; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateAccount", org.apache.thrift.protocol.TMessageType.CALL, 0)); + updateAccount_args args = new updateAccount_args(); + args.setPlugin(plugin); + args.setAccount(account); + args.setPassword(password); + args.setOptions(options); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_updateAccount(); + } + } + + public void removeAccount(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + removeAccount_call method_call = new removeAccount_call(plugin, account, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class removeAccount_call extends org.apache.thrift.async.TAsyncMethodCall { + private String plugin; + private String account; + + public removeAccount_call(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.plugin = plugin; + this.account = account; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("removeAccount", org.apache.thrift.protocol.TMessageType.CALL, 0)); + removeAccount_args args = new removeAccount_args(); + args.setPlugin(plugin); + args.setAccount(account); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_removeAccount(); + } + } + + public void login(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + login_call method_call = new login_call(username, password, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class login_call extends org.apache.thrift.async.TAsyncMethodCall { + private String username; + private String password; + + public login_call(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.username = username; + this.password = password; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("login", org.apache.thrift.protocol.TMessageType.CALL, 0)); + login_args args = new login_args(); + args.setUsername(username); + args.setPassword(password); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_login(); + } + } + + public void getUserData(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getUserData_call method_call = new getUserData_call(username, password, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getUserData_call extends org.apache.thrift.async.TAsyncMethodCall { + private String username; + private String password; + + public getUserData_call(String username, String password, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.username = username; + this.password = password; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getUserData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getUserData_args args = new getUserData_args(); + args.setUsername(username); + args.setPassword(password); + args.write(prot); + prot.writeMessageEnd(); + } + + public UserData getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getUserData(); + } + } + + public void getAllUserData(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getAllUserData_call method_call = new getAllUserData_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getAllUserData_call extends org.apache.thrift.async.TAsyncMethodCall { + public getAllUserData_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAllUserData", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getAllUserData_args args = new getAllUserData_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, UserData> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getAllUserData(); + } + } + + public void getServices(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getServices_call method_call = new getServices_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getServices_call extends org.apache.thrift.async.TAsyncMethodCall { + public getServices_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getServices", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getServices_args args = new getServices_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, Map<String, String>> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getServices(); + } + } + + public void hasService(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + hasService_call method_call = new hasService_call(plugin, func, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class hasService_call extends org.apache.thrift.async.TAsyncMethodCall { + private String plugin; + private String func; + + public hasService_call(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.plugin = plugin; + this.func = func; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("hasService", org.apache.thrift.protocol.TMessageType.CALL, 0)); + hasService_args args = new hasService_args(); + args.setPlugin(plugin); + args.setFunc(func); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_hasService(); + } + } + + public void call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + call_call method_call = new call_call(info, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class call_call extends org.apache.thrift.async.TAsyncMethodCall { + private ServiceCall info; + + public call_call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.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("call", org.apache.thrift.protocol.TMessageType.CALL, 0)); + call_args args = new call_args(); + args.setInfo(info); + args.write(prot); + prot.writeMessageEnd(); + } + + public String getResult() throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_call(); + } + } + + public void getAllInfo(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getAllInfo_call method_call = new getAllInfo_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getAllInfo_call extends org.apache.thrift.async.TAsyncMethodCall { + public getAllInfo_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAllInfo", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getAllInfo_args args = new getAllInfo_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, Map<String, String>> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getAllInfo(); + } + } + + public void getInfoByPlugin(String plugin, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getInfoByPlugin_call method_call = new getInfoByPlugin_call(plugin, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getInfoByPlugin_call extends org.apache.thrift.async.TAsyncMethodCall { + private String plugin; + + public getInfoByPlugin_call(String plugin, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.plugin = plugin; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getInfoByPlugin", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getInfoByPlugin_args args = new getInfoByPlugin_args(); + args.setPlugin(plugin); + args.write(prot); + prot.writeMessageEnd(); + } + + public Map<String, String> getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getInfoByPlugin(); + } + } + + public void isCaptchaWaiting(org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + isCaptchaWaiting_call method_call = new isCaptchaWaiting_call(resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class isCaptchaWaiting_call extends org.apache.thrift.async.TAsyncMethodCall { + public isCaptchaWaiting_call(org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("isCaptchaWaiting", org.apache.thrift.protocol.TMessageType.CALL, 0)); + isCaptchaWaiting_args args = new isCaptchaWaiting_args(); + args.write(prot); + prot.writeMessageEnd(); + } + + public boolean getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_isCaptchaWaiting(); + } + } + + public void getCaptchaTask(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getCaptchaTask_call method_call = new getCaptchaTask_call(exclusive, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getCaptchaTask_call extends org.apache.thrift.async.TAsyncMethodCall { + private boolean exclusive; + + public getCaptchaTask_call(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.exclusive = exclusive; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCaptchaTask", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getCaptchaTask_args args = new getCaptchaTask_args(); + args.setExclusive(exclusive); + args.write(prot); + prot.writeMessageEnd(); + } + + public CaptchaTask getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getCaptchaTask(); + } + } + + public void getCaptchaTaskStatus(int tid, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + getCaptchaTaskStatus_call method_call = new getCaptchaTaskStatus_call(tid, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class getCaptchaTaskStatus_call extends org.apache.thrift.async.TAsyncMethodCall { + private int tid; + + public getCaptchaTaskStatus_call(int tid, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tid = tid; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCaptchaTaskStatus", org.apache.thrift.protocol.TMessageType.CALL, 0)); + getCaptchaTaskStatus_args args = new getCaptchaTaskStatus_args(); + args.setTid(tid); + args.write(prot); + prot.writeMessageEnd(); + } + + public String getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + return (new Client(prot)).recv_getCaptchaTaskStatus(); + } + } + + public void setCaptchaResult(int tid, String result, org.apache.thrift.async.AsyncMethodCallback resultHandler) throws org.apache.thrift.TException { + checkReady(); + setCaptchaResult_call method_call = new setCaptchaResult_call(tid, result, resultHandler, this, ___protocolFactory, ___transport); + this.___currentMethod = method_call; + ___manager.call(method_call); + } + + public static class setCaptchaResult_call extends org.apache.thrift.async.TAsyncMethodCall { + private int tid; + private String result; + + public setCaptchaResult_call(int tid, String result, org.apache.thrift.async.AsyncMethodCallback resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException { + super(client, protocolFactory, transport, resultHandler, false); + this.tid = tid; + this.result = result; + } + + public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { + prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setCaptchaResult", org.apache.thrift.protocol.TMessageType.CALL, 0)); + setCaptchaResult_args args = new setCaptchaResult_args(); + args.setTid(tid); + args.setResult(result); + args.write(prot); + prot.writeMessageEnd(); + } + + public void getResult() throws org.apache.thrift.TException { + if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { + throw new IllegalStateException("Method call not finished!"); + } + org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); + org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); + (new Client(prot)).recv_setCaptchaResult(); + } + } + + } + + public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor<I> implements org.apache.thrift.TProcessor { + private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName()); + + public Processor(I iface) { + super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>())); + } + + protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) { + super(iface, getProcessMap(processMap)); + } + + private static <I extends Iface> Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) { + processMap.put("getConfigValue", new getConfigValue()); + processMap.put("setConfigValue", new setConfigValue()); + processMap.put("getConfig", new getConfig()); + processMap.put("getPluginConfig", new getPluginConfig()); + processMap.put("pauseServer", new pauseServer()); + processMap.put("unpauseServer", new unpauseServer()); + processMap.put("togglePause", new togglePause()); + processMap.put("statusServer", new statusServer()); + processMap.put("freeSpace", new freeSpace()); + processMap.put("getServerVersion", new getServerVersion()); + processMap.put("kill", new kill()); + processMap.put("restart", new restart()); + processMap.put("getLog", new getLog()); + processMap.put("isTimeDownload", new isTimeDownload()); + processMap.put("isTimeReconnect", new isTimeReconnect()); + processMap.put("toggleReconnect", new toggleReconnect()); + processMap.put("generatePackages", new generatePackages()); + processMap.put("checkURLs", new checkURLs()); + processMap.put("parseURLs", new parseURLs()); + processMap.put("checkOnlineStatus", new checkOnlineStatus()); + processMap.put("checkOnlineStatusContainer", new checkOnlineStatusContainer()); + processMap.put("pollResults", new pollResults()); + processMap.put("statusDownloads", new statusDownloads()); + processMap.put("getPackageData", new getPackageData()); + processMap.put("getPackageInfo", new getPackageInfo()); + processMap.put("getFileData", new getFileData()); + processMap.put("getQueue", new getQueue()); + processMap.put("getCollector", new getCollector()); + processMap.put("getQueueData", new getQueueData()); + processMap.put("getCollectorData", new getCollectorData()); + processMap.put("getPackageOrder", new getPackageOrder()); + processMap.put("getFileOrder", new getFileOrder()); + processMap.put("generateAndAddPackages", new generateAndAddPackages()); + processMap.put("addPackage", new addPackage()); + processMap.put("addFiles", new addFiles()); + processMap.put("uploadContainer", new uploadContainer()); + processMap.put("deleteFiles", new deleteFiles()); + processMap.put("deletePackages", new deletePackages()); + processMap.put("pushToQueue", new pushToQueue()); + processMap.put("pullFromQueue", new pullFromQueue()); + processMap.put("restartPackage", new restartPackage()); + processMap.put("restartFile", new restartFile()); + processMap.put("recheckPackage", new recheckPackage()); + processMap.put("stopAllDownloads", new stopAllDownloads()); + processMap.put("stopDownloads", new stopDownloads()); + processMap.put("setPackageName", new setPackageName()); + processMap.put("movePackage", new movePackage()); + processMap.put("moveFiles", new moveFiles()); + processMap.put("orderPackage", new orderPackage()); + processMap.put("orderFile", new orderFile()); + processMap.put("setPackageData", new setPackageData()); + processMap.put("deleteFinished", new deleteFinished()); + processMap.put("restartFailed", new restartFailed()); + processMap.put("getEvents", new getEvents()); + processMap.put("getAccounts", new getAccounts()); + processMap.put("getAccountTypes", new getAccountTypes()); + processMap.put("updateAccount", new updateAccount()); + processMap.put("removeAccount", new removeAccount()); + processMap.put("login", new login()); + processMap.put("getUserData", new getUserData()); + processMap.put("getAllUserData", new getAllUserData()); + processMap.put("getServices", new getServices()); + processMap.put("hasService", new hasService()); + processMap.put("call", new call()); + processMap.put("getAllInfo", new getAllInfo()); + processMap.put("getInfoByPlugin", new getInfoByPlugin()); + processMap.put("isCaptchaWaiting", new isCaptchaWaiting()); + processMap.put("getCaptchaTask", new getCaptchaTask()); + processMap.put("getCaptchaTaskStatus", new getCaptchaTaskStatus()); + processMap.put("setCaptchaResult", new setCaptchaResult()); + return processMap; + } + + public static class getConfigValue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getConfigValue_args> { + public getConfigValue() { + super("getConfigValue"); + } + + public getConfigValue_args getEmptyArgsInstance() { + return new getConfigValue_args(); + } + + protected boolean isOneway() { + return false; + } + + public getConfigValue_result getResult(I iface, getConfigValue_args args) throws org.apache.thrift.TException { + getConfigValue_result result = new getConfigValue_result(); + result.success = iface.getConfigValue(args.category, args.option, args.section); + return result; + } + } + + public static class setConfigValue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setConfigValue_args> { + public setConfigValue() { + super("setConfigValue"); + } + + public setConfigValue_args getEmptyArgsInstance() { + return new setConfigValue_args(); + } + + protected boolean isOneway() { + return false; + } + + public setConfigValue_result getResult(I iface, setConfigValue_args args) throws org.apache.thrift.TException { + setConfigValue_result result = new setConfigValue_result(); + iface.setConfigValue(args.category, args.option, args.value, args.section); + return result; + } + } + + public static class getConfig<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getConfig_args> { + public getConfig() { + super("getConfig"); + } + + public getConfig_args getEmptyArgsInstance() { + return new getConfig_args(); + } + + protected boolean isOneway() { + return false; + } + + public getConfig_result getResult(I iface, getConfig_args args) throws org.apache.thrift.TException { + getConfig_result result = new getConfig_result(); + result.success = iface.getConfig(); + return result; + } + } + + public static class getPluginConfig<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPluginConfig_args> { + public getPluginConfig() { + super("getPluginConfig"); + } + + public getPluginConfig_args getEmptyArgsInstance() { + return new getPluginConfig_args(); + } + + protected boolean isOneway() { + return false; + } + + public getPluginConfig_result getResult(I iface, getPluginConfig_args args) throws org.apache.thrift.TException { + getPluginConfig_result result = new getPluginConfig_result(); + result.success = iface.getPluginConfig(); + return result; + } + } + + public static class pauseServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pauseServer_args> { + public pauseServer() { + super("pauseServer"); + } + + public pauseServer_args getEmptyArgsInstance() { + return new pauseServer_args(); + } + + protected boolean isOneway() { + return false; + } + + public pauseServer_result getResult(I iface, pauseServer_args args) throws org.apache.thrift.TException { + pauseServer_result result = new pauseServer_result(); + iface.pauseServer(); + return result; + } + } + + public static class unpauseServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, unpauseServer_args> { + public unpauseServer() { + super("unpauseServer"); + } + + public unpauseServer_args getEmptyArgsInstance() { + return new unpauseServer_args(); + } + + protected boolean isOneway() { + return false; + } + + public unpauseServer_result getResult(I iface, unpauseServer_args args) throws org.apache.thrift.TException { + unpauseServer_result result = new unpauseServer_result(); + iface.unpauseServer(); + return result; + } + } + + public static class togglePause<I extends Iface> extends org.apache.thrift.ProcessFunction<I, togglePause_args> { + public togglePause() { + super("togglePause"); + } + + public togglePause_args getEmptyArgsInstance() { + return new togglePause_args(); + } + + protected boolean isOneway() { + return false; + } + + public togglePause_result getResult(I iface, togglePause_args args) throws org.apache.thrift.TException { + togglePause_result result = new togglePause_result(); + result.success = iface.togglePause(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class statusServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, statusServer_args> { + public statusServer() { + super("statusServer"); + } + + public statusServer_args getEmptyArgsInstance() { + return new statusServer_args(); + } + + protected boolean isOneway() { + return false; + } + + public statusServer_result getResult(I iface, statusServer_args args) throws org.apache.thrift.TException { + statusServer_result result = new statusServer_result(); + result.success = iface.statusServer(); + return result; + } + } + + public static class freeSpace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, freeSpace_args> { + public freeSpace() { + super("freeSpace"); + } + + public freeSpace_args getEmptyArgsInstance() { + return new freeSpace_args(); + } + + protected boolean isOneway() { + return false; + } + + public freeSpace_result getResult(I iface, freeSpace_args args) throws org.apache.thrift.TException { + freeSpace_result result = new freeSpace_result(); + result.success = iface.freeSpace(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class getServerVersion<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getServerVersion_args> { + public getServerVersion() { + super("getServerVersion"); + } + + public getServerVersion_args getEmptyArgsInstance() { + return new getServerVersion_args(); + } + + protected boolean isOneway() { + return false; + } + + public getServerVersion_result getResult(I iface, getServerVersion_args args) throws org.apache.thrift.TException { + getServerVersion_result result = new getServerVersion_result(); + result.success = iface.getServerVersion(); + return result; + } + } + + public static class kill<I extends Iface> extends org.apache.thrift.ProcessFunction<I, kill_args> { + public kill() { + super("kill"); + } + + public kill_args getEmptyArgsInstance() { + return new kill_args(); + } + + protected boolean isOneway() { + return false; + } + + public kill_result getResult(I iface, kill_args args) throws org.apache.thrift.TException { + kill_result result = new kill_result(); + iface.kill(); + return result; + } + } + + public static class restart<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restart_args> { + public restart() { + super("restart"); + } + + public restart_args getEmptyArgsInstance() { + return new restart_args(); + } + + protected boolean isOneway() { + return false; + } + + public restart_result getResult(I iface, restart_args args) throws org.apache.thrift.TException { + restart_result result = new restart_result(); + iface.restart(); + return result; + } + } + + public static class getLog<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLog_args> { + public getLog() { + super("getLog"); + } + + public getLog_args getEmptyArgsInstance() { + return new getLog_args(); + } + + protected boolean isOneway() { + return false; + } + + public getLog_result getResult(I iface, getLog_args args) throws org.apache.thrift.TException { + getLog_result result = new getLog_result(); + result.success = iface.getLog(args.offset); + return result; + } + } + + public static class isTimeDownload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTimeDownload_args> { + public isTimeDownload() { + super("isTimeDownload"); + } + + public isTimeDownload_args getEmptyArgsInstance() { + return new isTimeDownload_args(); + } + + protected boolean isOneway() { + return false; + } + + public isTimeDownload_result getResult(I iface, isTimeDownload_args args) throws org.apache.thrift.TException { + isTimeDownload_result result = new isTimeDownload_result(); + result.success = iface.isTimeDownload(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class isTimeReconnect<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTimeReconnect_args> { + public isTimeReconnect() { + super("isTimeReconnect"); + } + + public isTimeReconnect_args getEmptyArgsInstance() { + return new isTimeReconnect_args(); + } + + protected boolean isOneway() { + return false; + } + + public isTimeReconnect_result getResult(I iface, isTimeReconnect_args args) throws org.apache.thrift.TException { + isTimeReconnect_result result = new isTimeReconnect_result(); + result.success = iface.isTimeReconnect(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class toggleReconnect<I extends Iface> extends org.apache.thrift.ProcessFunction<I, toggleReconnect_args> { + public toggleReconnect() { + super("toggleReconnect"); + } + + public toggleReconnect_args getEmptyArgsInstance() { + return new toggleReconnect_args(); + } + + protected boolean isOneway() { + return false; + } + + public toggleReconnect_result getResult(I iface, toggleReconnect_args args) throws org.apache.thrift.TException { + toggleReconnect_result result = new toggleReconnect_result(); + result.success = iface.toggleReconnect(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class generatePackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, generatePackages_args> { + public generatePackages() { + super("generatePackages"); + } + + public generatePackages_args getEmptyArgsInstance() { + return new generatePackages_args(); + } + + protected boolean isOneway() { + return false; + } + + public generatePackages_result getResult(I iface, generatePackages_args args) throws org.apache.thrift.TException { + generatePackages_result result = new generatePackages_result(); + result.success = iface.generatePackages(args.links); + return result; + } + } + + public static class checkURLs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkURLs_args> { + public checkURLs() { + super("checkURLs"); + } + + public checkURLs_args getEmptyArgsInstance() { + return new checkURLs_args(); + } + + protected boolean isOneway() { + return false; + } + + public checkURLs_result getResult(I iface, checkURLs_args args) throws org.apache.thrift.TException { + checkURLs_result result = new checkURLs_result(); + result.success = iface.checkURLs(args.urls); + return result; + } + } + + public static class parseURLs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, parseURLs_args> { + public parseURLs() { + super("parseURLs"); + } + + public parseURLs_args getEmptyArgsInstance() { + return new parseURLs_args(); + } + + protected boolean isOneway() { + return false; + } + + public parseURLs_result getResult(I iface, parseURLs_args args) throws org.apache.thrift.TException { + parseURLs_result result = new parseURLs_result(); + result.success = iface.parseURLs(args.html, args.url); + return result; + } + } + + public static class checkOnlineStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkOnlineStatus_args> { + public checkOnlineStatus() { + super("checkOnlineStatus"); + } + + public checkOnlineStatus_args getEmptyArgsInstance() { + return new checkOnlineStatus_args(); + } + + protected boolean isOneway() { + return false; + } + + public checkOnlineStatus_result getResult(I iface, checkOnlineStatus_args args) throws org.apache.thrift.TException { + checkOnlineStatus_result result = new checkOnlineStatus_result(); + result.success = iface.checkOnlineStatus(args.urls); + return result; + } + } + + public static class checkOnlineStatusContainer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkOnlineStatusContainer_args> { + public checkOnlineStatusContainer() { + super("checkOnlineStatusContainer"); + } + + public checkOnlineStatusContainer_args getEmptyArgsInstance() { + return new checkOnlineStatusContainer_args(); + } + + protected boolean isOneway() { + return false; + } + + public checkOnlineStatusContainer_result getResult(I iface, checkOnlineStatusContainer_args args) throws org.apache.thrift.TException { + checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); + result.success = iface.checkOnlineStatusContainer(args.urls, args.filename, args.data); + return result; + } + } + + public static class pollResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pollResults_args> { + public pollResults() { + super("pollResults"); + } + + public pollResults_args getEmptyArgsInstance() { + return new pollResults_args(); + } + + protected boolean isOneway() { + return false; + } + + public pollResults_result getResult(I iface, pollResults_args args) throws org.apache.thrift.TException { + pollResults_result result = new pollResults_result(); + result.success = iface.pollResults(args.rid); + return result; + } + } + + public static class statusDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, statusDownloads_args> { + public statusDownloads() { + super("statusDownloads"); + } + + public statusDownloads_args getEmptyArgsInstance() { + return new statusDownloads_args(); + } + + protected boolean isOneway() { + return false; + } + + public statusDownloads_result getResult(I iface, statusDownloads_args args) throws org.apache.thrift.TException { + statusDownloads_result result = new statusDownloads_result(); + result.success = iface.statusDownloads(); + return result; + } + } + + public static class getPackageData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageData_args> { + public getPackageData() { + super("getPackageData"); + } + + public getPackageData_args getEmptyArgsInstance() { + return new getPackageData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getPackageData_result getResult(I iface, getPackageData_args args) throws org.apache.thrift.TException { + getPackageData_result result = new getPackageData_result(); + try { + result.success = iface.getPackageData(args.pid); + } catch (PackageDoesNotExists e) { + result.e = e; + } + return result; + } + } + + public static class getPackageInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageInfo_args> { + public getPackageInfo() { + super("getPackageInfo"); + } + + public getPackageInfo_args getEmptyArgsInstance() { + return new getPackageInfo_args(); + } + + protected boolean isOneway() { + return false; + } + + public getPackageInfo_result getResult(I iface, getPackageInfo_args args) throws org.apache.thrift.TException { + getPackageInfo_result result = new getPackageInfo_result(); + try { + result.success = iface.getPackageInfo(args.pid); + } catch (PackageDoesNotExists e) { + result.e = e; + } + return result; + } + } + + public static class getFileData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getFileData_args> { + public getFileData() { + super("getFileData"); + } + + public getFileData_args getEmptyArgsInstance() { + return new getFileData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getFileData_result getResult(I iface, getFileData_args args) throws org.apache.thrift.TException { + getFileData_result result = new getFileData_result(); + try { + result.success = iface.getFileData(args.fid); + } catch (FileDoesNotExists e) { + result.e = e; + } + return result; + } + } + + public static class getQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getQueue_args> { + public getQueue() { + super("getQueue"); + } + + public getQueue_args getEmptyArgsInstance() { + return new getQueue_args(); + } + + protected boolean isOneway() { + return false; + } + + public getQueue_result getResult(I iface, getQueue_args args) throws org.apache.thrift.TException { + getQueue_result result = new getQueue_result(); + result.success = iface.getQueue(); + return result; + } + } + + public static class getCollector<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCollector_args> { + public getCollector() { + super("getCollector"); + } + + public getCollector_args getEmptyArgsInstance() { + return new getCollector_args(); + } + + protected boolean isOneway() { + return false; + } + + public getCollector_result getResult(I iface, getCollector_args args) throws org.apache.thrift.TException { + getCollector_result result = new getCollector_result(); + result.success = iface.getCollector(); + return result; + } + } + + public static class getQueueData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getQueueData_args> { + public getQueueData() { + super("getQueueData"); + } + + public getQueueData_args getEmptyArgsInstance() { + return new getQueueData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getQueueData_result getResult(I iface, getQueueData_args args) throws org.apache.thrift.TException { + getQueueData_result result = new getQueueData_result(); + result.success = iface.getQueueData(); + return result; + } + } + + public static class getCollectorData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCollectorData_args> { + public getCollectorData() { + super("getCollectorData"); + } + + public getCollectorData_args getEmptyArgsInstance() { + return new getCollectorData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getCollectorData_result getResult(I iface, getCollectorData_args args) throws org.apache.thrift.TException { + getCollectorData_result result = new getCollectorData_result(); + result.success = iface.getCollectorData(); + return result; + } + } + + public static class getPackageOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageOrder_args> { + public getPackageOrder() { + super("getPackageOrder"); + } + + public getPackageOrder_args getEmptyArgsInstance() { + return new getPackageOrder_args(); + } + + protected boolean isOneway() { + return false; + } + + public getPackageOrder_result getResult(I iface, getPackageOrder_args args) throws org.apache.thrift.TException { + getPackageOrder_result result = new getPackageOrder_result(); + result.success = iface.getPackageOrder(args.destination); + return result; + } + } + + public static class getFileOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getFileOrder_args> { + public getFileOrder() { + super("getFileOrder"); + } + + public getFileOrder_args getEmptyArgsInstance() { + return new getFileOrder_args(); + } + + protected boolean isOneway() { + return false; + } + + public getFileOrder_result getResult(I iface, getFileOrder_args args) throws org.apache.thrift.TException { + getFileOrder_result result = new getFileOrder_result(); + result.success = iface.getFileOrder(args.pid); + return result; + } + } + + public static class generateAndAddPackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, generateAndAddPackages_args> { + public generateAndAddPackages() { + super("generateAndAddPackages"); + } + + public generateAndAddPackages_args getEmptyArgsInstance() { + return new generateAndAddPackages_args(); + } + + protected boolean isOneway() { + return false; + } + + public generateAndAddPackages_result getResult(I iface, generateAndAddPackages_args args) throws org.apache.thrift.TException { + generateAndAddPackages_result result = new generateAndAddPackages_result(); + result.success = iface.generateAndAddPackages(args.links, args.dest); + return result; + } + } + + public static class addPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addPackage_args> { + public addPackage() { + super("addPackage"); + } + + public addPackage_args getEmptyArgsInstance() { + return new addPackage_args(); + } + + protected boolean isOneway() { + return false; + } + + public addPackage_result getResult(I iface, addPackage_args args) throws org.apache.thrift.TException { + addPackage_result result = new addPackage_result(); + result.success = iface.addPackage(args.name, args.links, args.dest); + result.setSuccessIsSet(true); + return result; + } + } + + public static class addFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addFiles_args> { + public addFiles() { + super("addFiles"); + } + + public addFiles_args getEmptyArgsInstance() { + return new addFiles_args(); + } + + protected boolean isOneway() { + return false; + } + + public addFiles_result getResult(I iface, addFiles_args args) throws org.apache.thrift.TException { + addFiles_result result = new addFiles_result(); + iface.addFiles(args.pid, args.links); + return result; + } + } + + public static class uploadContainer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, uploadContainer_args> { + public uploadContainer() { + super("uploadContainer"); + } + + public uploadContainer_args getEmptyArgsInstance() { + return new uploadContainer_args(); + } + + protected boolean isOneway() { + return false; + } + + public uploadContainer_result getResult(I iface, uploadContainer_args args) throws org.apache.thrift.TException { + uploadContainer_result result = new uploadContainer_result(); + iface.uploadContainer(args.filename, args.data); + return result; + } + } + + public static class deleteFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteFiles_args> { + public deleteFiles() { + super("deleteFiles"); + } + + public deleteFiles_args getEmptyArgsInstance() { + return new deleteFiles_args(); + } + + protected boolean isOneway() { + return false; + } + + public deleteFiles_result getResult(I iface, deleteFiles_args args) throws org.apache.thrift.TException { + deleteFiles_result result = new deleteFiles_result(); + iface.deleteFiles(args.fids); + return result; + } + } + + public static class deletePackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deletePackages_args> { + public deletePackages() { + super("deletePackages"); + } + + public deletePackages_args getEmptyArgsInstance() { + return new deletePackages_args(); + } + + protected boolean isOneway() { + return false; + } + + public deletePackages_result getResult(I iface, deletePackages_args args) throws org.apache.thrift.TException { + deletePackages_result result = new deletePackages_result(); + iface.deletePackages(args.pids); + return result; + } + } + + public static class pushToQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pushToQueue_args> { + public pushToQueue() { + super("pushToQueue"); + } + + public pushToQueue_args getEmptyArgsInstance() { + return new pushToQueue_args(); + } + + protected boolean isOneway() { + return false; + } + + public pushToQueue_result getResult(I iface, pushToQueue_args args) throws org.apache.thrift.TException { + pushToQueue_result result = new pushToQueue_result(); + iface.pushToQueue(args.pid); + return result; + } + } + + public static class pullFromQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pullFromQueue_args> { + public pullFromQueue() { + super("pullFromQueue"); + } + + public pullFromQueue_args getEmptyArgsInstance() { + return new pullFromQueue_args(); + } + + protected boolean isOneway() { + return false; + } + + public pullFromQueue_result getResult(I iface, pullFromQueue_args args) throws org.apache.thrift.TException { + pullFromQueue_result result = new pullFromQueue_result(); + iface.pullFromQueue(args.pid); + return result; + } + } + + public static class restartPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartPackage_args> { + public restartPackage() { + super("restartPackage"); + } + + public restartPackage_args getEmptyArgsInstance() { + return new restartPackage_args(); + } + + protected boolean isOneway() { + return false; + } + + public restartPackage_result getResult(I iface, restartPackage_args args) throws org.apache.thrift.TException { + restartPackage_result result = new restartPackage_result(); + iface.restartPackage(args.pid); + return result; + } + } + + public static class restartFile<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartFile_args> { + public restartFile() { + super("restartFile"); + } + + public restartFile_args getEmptyArgsInstance() { + return new restartFile_args(); + } + + protected boolean isOneway() { + return false; + } + + public restartFile_result getResult(I iface, restartFile_args args) throws org.apache.thrift.TException { + restartFile_result result = new restartFile_result(); + iface.restartFile(args.fid); + return result; + } + } + + public static class recheckPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, recheckPackage_args> { + public recheckPackage() { + super("recheckPackage"); + } + + public recheckPackage_args getEmptyArgsInstance() { + return new recheckPackage_args(); + } + + protected boolean isOneway() { + return false; + } + + public recheckPackage_result getResult(I iface, recheckPackage_args args) throws org.apache.thrift.TException { + recheckPackage_result result = new recheckPackage_result(); + iface.recheckPackage(args.pid); + return result; + } + } + + public static class stopAllDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, stopAllDownloads_args> { + public stopAllDownloads() { + super("stopAllDownloads"); + } + + public stopAllDownloads_args getEmptyArgsInstance() { + return new stopAllDownloads_args(); + } + + protected boolean isOneway() { + return false; + } + + public stopAllDownloads_result getResult(I iface, stopAllDownloads_args args) throws org.apache.thrift.TException { + stopAllDownloads_result result = new stopAllDownloads_result(); + iface.stopAllDownloads(); + return result; + } + } + + public static class stopDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, stopDownloads_args> { + public stopDownloads() { + super("stopDownloads"); + } + + public stopDownloads_args getEmptyArgsInstance() { + return new stopDownloads_args(); + } + + protected boolean isOneway() { + return false; + } + + public stopDownloads_result getResult(I iface, stopDownloads_args args) throws org.apache.thrift.TException { + stopDownloads_result result = new stopDownloads_result(); + iface.stopDownloads(args.fids); + return result; + } + } + + public static class setPackageName<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setPackageName_args> { + public setPackageName() { + super("setPackageName"); + } + + public setPackageName_args getEmptyArgsInstance() { + return new setPackageName_args(); + } + + protected boolean isOneway() { + return false; + } + + public setPackageName_result getResult(I iface, setPackageName_args args) throws org.apache.thrift.TException { + setPackageName_result result = new setPackageName_result(); + iface.setPackageName(args.pid, args.name); + return result; + } + } + + public static class movePackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, movePackage_args> { + public movePackage() { + super("movePackage"); + } + + public movePackage_args getEmptyArgsInstance() { + return new movePackage_args(); + } + + protected boolean isOneway() { + return false; + } + + public movePackage_result getResult(I iface, movePackage_args args) throws org.apache.thrift.TException { + movePackage_result result = new movePackage_result(); + iface.movePackage(args.destination, args.pid); + return result; + } + } + + public static class moveFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, moveFiles_args> { + public moveFiles() { + super("moveFiles"); + } + + public moveFiles_args getEmptyArgsInstance() { + return new moveFiles_args(); + } + + protected boolean isOneway() { + return false; + } + + public moveFiles_result getResult(I iface, moveFiles_args args) throws org.apache.thrift.TException { + moveFiles_result result = new moveFiles_result(); + iface.moveFiles(args.fids, args.pid); + return result; + } + } + + public static class orderPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, orderPackage_args> { + public orderPackage() { + super("orderPackage"); + } + + public orderPackage_args getEmptyArgsInstance() { + return new orderPackage_args(); + } + + protected boolean isOneway() { + return false; + } + + public orderPackage_result getResult(I iface, orderPackage_args args) throws org.apache.thrift.TException { + orderPackage_result result = new orderPackage_result(); + iface.orderPackage(args.pid, args.position); + return result; + } + } + + public static class orderFile<I extends Iface> extends org.apache.thrift.ProcessFunction<I, orderFile_args> { + public orderFile() { + super("orderFile"); + } + + public orderFile_args getEmptyArgsInstance() { + return new orderFile_args(); + } + + protected boolean isOneway() { + return false; + } + + public orderFile_result getResult(I iface, orderFile_args args) throws org.apache.thrift.TException { + orderFile_result result = new orderFile_result(); + iface.orderFile(args.fid, args.position); + return result; + } + } + + public static class setPackageData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setPackageData_args> { + public setPackageData() { + super("setPackageData"); + } + + public setPackageData_args getEmptyArgsInstance() { + return new setPackageData_args(); + } + + protected boolean isOneway() { + return false; + } + + public setPackageData_result getResult(I iface, setPackageData_args args) throws org.apache.thrift.TException { + setPackageData_result result = new setPackageData_result(); + try { + iface.setPackageData(args.pid, args.data); + } catch (PackageDoesNotExists e) { + result.e = e; + } + return result; + } + } + + public static class deleteFinished<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteFinished_args> { + public deleteFinished() { + super("deleteFinished"); + } + + public deleteFinished_args getEmptyArgsInstance() { + return new deleteFinished_args(); + } + + protected boolean isOneway() { + return false; + } + + public deleteFinished_result getResult(I iface, deleteFinished_args args) throws org.apache.thrift.TException { + deleteFinished_result result = new deleteFinished_result(); + result.success = iface.deleteFinished(); + return result; + } + } + + public static class restartFailed<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartFailed_args> { + public restartFailed() { + super("restartFailed"); + } + + public restartFailed_args getEmptyArgsInstance() { + return new restartFailed_args(); + } + + protected boolean isOneway() { + return false; + } + + public restartFailed_result getResult(I iface, restartFailed_args args) throws org.apache.thrift.TException { + restartFailed_result result = new restartFailed_result(); + iface.restartFailed(); + return result; + } + } + + public static class getEvents<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getEvents_args> { + public getEvents() { + super("getEvents"); + } + + public getEvents_args getEmptyArgsInstance() { + return new getEvents_args(); + } + + protected boolean isOneway() { + return false; + } + + public getEvents_result getResult(I iface, getEvents_args args) throws org.apache.thrift.TException { + getEvents_result result = new getEvents_result(); + result.success = iface.getEvents(args.uuid); + return result; + } + } + + public static class getAccounts<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAccounts_args> { + public getAccounts() { + super("getAccounts"); + } + + public getAccounts_args getEmptyArgsInstance() { + return new getAccounts_args(); + } + + protected boolean isOneway() { + return false; + } + + public getAccounts_result getResult(I iface, getAccounts_args args) throws org.apache.thrift.TException { + getAccounts_result result = new getAccounts_result(); + result.success = iface.getAccounts(args.refresh); + return result; + } + } + + public static class getAccountTypes<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAccountTypes_args> { + public getAccountTypes() { + super("getAccountTypes"); + } + + public getAccountTypes_args getEmptyArgsInstance() { + return new getAccountTypes_args(); + } + + protected boolean isOneway() { + return false; + } + + public getAccountTypes_result getResult(I iface, getAccountTypes_args args) throws org.apache.thrift.TException { + getAccountTypes_result result = new getAccountTypes_result(); + result.success = iface.getAccountTypes(); + return result; + } + } + + public static class updateAccount<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateAccount_args> { + public updateAccount() { + super("updateAccount"); + } + + public updateAccount_args getEmptyArgsInstance() { + return new updateAccount_args(); + } + + protected boolean isOneway() { + return false; + } + + public updateAccount_result getResult(I iface, updateAccount_args args) throws org.apache.thrift.TException { + updateAccount_result result = new updateAccount_result(); + iface.updateAccount(args.plugin, args.account, args.password, args.options); + return result; + } + } + + public static class removeAccount<I extends Iface> extends org.apache.thrift.ProcessFunction<I, removeAccount_args> { + public removeAccount() { + super("removeAccount"); + } + + public removeAccount_args getEmptyArgsInstance() { + return new removeAccount_args(); + } + + protected boolean isOneway() { + return false; + } + + public removeAccount_result getResult(I iface, removeAccount_args args) throws org.apache.thrift.TException { + removeAccount_result result = new removeAccount_result(); + iface.removeAccount(args.plugin, args.account); + return result; + } + } + + public static class login<I extends Iface> extends org.apache.thrift.ProcessFunction<I, login_args> { + public login() { + super("login"); + } + + public login_args getEmptyArgsInstance() { + return new login_args(); + } + + protected boolean isOneway() { + return false; + } + + public login_result getResult(I iface, login_args args) throws org.apache.thrift.TException { + login_result result = new login_result(); + result.success = iface.login(args.username, args.password); + result.setSuccessIsSet(true); + return result; + } + } + + public static class getUserData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getUserData_args> { + public getUserData() { + super("getUserData"); + } + + public getUserData_args getEmptyArgsInstance() { + return new getUserData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getUserData_result getResult(I iface, getUserData_args args) throws org.apache.thrift.TException { + getUserData_result result = new getUserData_result(); + result.success = iface.getUserData(args.username, args.password); + return result; + } + } + + public static class getAllUserData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllUserData_args> { + public getAllUserData() { + super("getAllUserData"); + } + + public getAllUserData_args getEmptyArgsInstance() { + return new getAllUserData_args(); + } + + protected boolean isOneway() { + return false; + } + + public getAllUserData_result getResult(I iface, getAllUserData_args args) throws org.apache.thrift.TException { + getAllUserData_result result = new getAllUserData_result(); + result.success = iface.getAllUserData(); + return result; + } + } + + public static class getServices<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getServices_args> { + public getServices() { + super("getServices"); + } + + public getServices_args getEmptyArgsInstance() { + return new getServices_args(); + } + + protected boolean isOneway() { + return false; + } + + public getServices_result getResult(I iface, getServices_args args) throws org.apache.thrift.TException { + getServices_result result = new getServices_result(); + result.success = iface.getServices(); + return result; + } + } + + public static class hasService<I extends Iface> extends org.apache.thrift.ProcessFunction<I, hasService_args> { + public hasService() { + super("hasService"); + } + + public hasService_args getEmptyArgsInstance() { + return new hasService_args(); + } + + protected boolean isOneway() { + return false; + } + + public hasService_result getResult(I iface, hasService_args args) throws org.apache.thrift.TException { + hasService_result result = new hasService_result(); + result.success = iface.hasService(args.plugin, args.func); + result.setSuccessIsSet(true); + return result; + } + } + + public static class call<I extends Iface> extends org.apache.thrift.ProcessFunction<I, call_args> { + public call() { + super("call"); + } + + public call_args getEmptyArgsInstance() { + return new call_args(); + } + + protected boolean isOneway() { + return false; + } + + public call_result getResult(I iface, call_args args) throws org.apache.thrift.TException { + call_result result = new call_result(); + try { + result.success = iface.call(args.info); + } catch (ServiceDoesNotExists ex) { + result.ex = ex; + } catch (ServiceException e) { + result.e = e; + } + return result; + } + } + + public static class getAllInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllInfo_args> { + public getAllInfo() { + super("getAllInfo"); + } + + public getAllInfo_args getEmptyArgsInstance() { + return new getAllInfo_args(); + } + + protected boolean isOneway() { + return false; + } + + public getAllInfo_result getResult(I iface, getAllInfo_args args) throws org.apache.thrift.TException { + getAllInfo_result result = new getAllInfo_result(); + result.success = iface.getAllInfo(); + return result; + } + } + + public static class getInfoByPlugin<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getInfoByPlugin_args> { + public getInfoByPlugin() { + super("getInfoByPlugin"); + } + + public getInfoByPlugin_args getEmptyArgsInstance() { + return new getInfoByPlugin_args(); + } + + protected boolean isOneway() { + return false; + } + + public getInfoByPlugin_result getResult(I iface, getInfoByPlugin_args args) throws org.apache.thrift.TException { + getInfoByPlugin_result result = new getInfoByPlugin_result(); + result.success = iface.getInfoByPlugin(args.plugin); + return result; + } + } + + public static class isCaptchaWaiting<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isCaptchaWaiting_args> { + public isCaptchaWaiting() { + super("isCaptchaWaiting"); + } + + public isCaptchaWaiting_args getEmptyArgsInstance() { + return new isCaptchaWaiting_args(); + } + + protected boolean isOneway() { + return false; + } + + public isCaptchaWaiting_result getResult(I iface, isCaptchaWaiting_args args) throws org.apache.thrift.TException { + isCaptchaWaiting_result result = new isCaptchaWaiting_result(); + result.success = iface.isCaptchaWaiting(); + result.setSuccessIsSet(true); + return result; + } + } + + public static class getCaptchaTask<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCaptchaTask_args> { + public getCaptchaTask() { + super("getCaptchaTask"); + } + + public getCaptchaTask_args getEmptyArgsInstance() { + return new getCaptchaTask_args(); + } + + protected boolean isOneway() { + return false; + } + + public getCaptchaTask_result getResult(I iface, getCaptchaTask_args args) throws org.apache.thrift.TException { + getCaptchaTask_result result = new getCaptchaTask_result(); + result.success = iface.getCaptchaTask(args.exclusive); + return result; + } + } + + public static class getCaptchaTaskStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCaptchaTaskStatus_args> { + public getCaptchaTaskStatus() { + super("getCaptchaTaskStatus"); + } + + public getCaptchaTaskStatus_args getEmptyArgsInstance() { + return new getCaptchaTaskStatus_args(); + } + + protected boolean isOneway() { + return false; + } + + public getCaptchaTaskStatus_result getResult(I iface, getCaptchaTaskStatus_args args) throws org.apache.thrift.TException { + getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); + result.success = iface.getCaptchaTaskStatus(args.tid); + return result; + } + } + + public static class setCaptchaResult<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setCaptchaResult_args> { + public setCaptchaResult() { + super("setCaptchaResult"); + } + + public setCaptchaResult_args getEmptyArgsInstance() { + return new setCaptchaResult_args(); + } + + protected boolean isOneway() { + return false; + } + + public setCaptchaResult_result getResult(I iface, setCaptchaResult_args args) throws org.apache.thrift.TException { + setCaptchaResult_result result = new setCaptchaResult_result(); + iface.setCaptchaResult(args.tid, args.result); + return result; + } + } + + } + + public static class AsyncProcessor<I extends AsyncIface> extends org.apache.thrift.TBaseAsyncProcessor<I> { + private static final Logger LOGGER = LoggerFactory.getLogger(AsyncProcessor.class.getName()); + + public AsyncProcessor(I iface) { + super(iface, getProcessMap(new HashMap<String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>>())); + } + + protected AsyncProcessor(I iface, Map<String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) { + super(iface, getProcessMap(processMap)); + } + + private static <I extends AsyncIface> Map<String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> getProcessMap(Map<String, org.apache.thrift.AsyncProcessFunction<I, ? extends org.apache.thrift.TBase, ?>> processMap) { + processMap.put("getConfigValue", new getConfigValue()); + processMap.put("setConfigValue", new setConfigValue()); + processMap.put("getConfig", new getConfig()); + processMap.put("getPluginConfig", new getPluginConfig()); + processMap.put("pauseServer", new pauseServer()); + processMap.put("unpauseServer", new unpauseServer()); + processMap.put("togglePause", new togglePause()); + processMap.put("statusServer", new statusServer()); + processMap.put("freeSpace", new freeSpace()); + processMap.put("getServerVersion", new getServerVersion()); + processMap.put("kill", new kill()); + processMap.put("restart", new restart()); + processMap.put("getLog", new getLog()); + processMap.put("isTimeDownload", new isTimeDownload()); + processMap.put("isTimeReconnect", new isTimeReconnect()); + processMap.put("toggleReconnect", new toggleReconnect()); + processMap.put("generatePackages", new generatePackages()); + processMap.put("checkURLs", new checkURLs()); + processMap.put("parseURLs", new parseURLs()); + processMap.put("checkOnlineStatus", new checkOnlineStatus()); + processMap.put("checkOnlineStatusContainer", new checkOnlineStatusContainer()); + processMap.put("pollResults", new pollResults()); + processMap.put("statusDownloads", new statusDownloads()); + processMap.put("getPackageData", new getPackageData()); + processMap.put("getPackageInfo", new getPackageInfo()); + processMap.put("getFileData", new getFileData()); + processMap.put("getQueue", new getQueue()); + processMap.put("getCollector", new getCollector()); + processMap.put("getQueueData", new getQueueData()); + processMap.put("getCollectorData", new getCollectorData()); + processMap.put("getPackageOrder", new getPackageOrder()); + processMap.put("getFileOrder", new getFileOrder()); + processMap.put("generateAndAddPackages", new generateAndAddPackages()); + processMap.put("addPackage", new addPackage()); + processMap.put("addFiles", new addFiles()); + processMap.put("uploadContainer", new uploadContainer()); + processMap.put("deleteFiles", new deleteFiles()); + processMap.put("deletePackages", new deletePackages()); + processMap.put("pushToQueue", new pushToQueue()); + processMap.put("pullFromQueue", new pullFromQueue()); + processMap.put("restartPackage", new restartPackage()); + processMap.put("restartFile", new restartFile()); + processMap.put("recheckPackage", new recheckPackage()); + processMap.put("stopAllDownloads", new stopAllDownloads()); + processMap.put("stopDownloads", new stopDownloads()); + processMap.put("setPackageName", new setPackageName()); + processMap.put("movePackage", new movePackage()); + processMap.put("moveFiles", new moveFiles()); + processMap.put("orderPackage", new orderPackage()); + processMap.put("orderFile", new orderFile()); + processMap.put("setPackageData", new setPackageData()); + processMap.put("deleteFinished", new deleteFinished()); + processMap.put("restartFailed", new restartFailed()); + processMap.put("getEvents", new getEvents()); + processMap.put("getAccounts", new getAccounts()); + processMap.put("getAccountTypes", new getAccountTypes()); + processMap.put("updateAccount", new updateAccount()); + processMap.put("removeAccount", new removeAccount()); + processMap.put("login", new login()); + processMap.put("getUserData", new getUserData()); + processMap.put("getAllUserData", new getAllUserData()); + processMap.put("getServices", new getServices()); + processMap.put("hasService", new hasService()); + processMap.put("call", new call()); + processMap.put("getAllInfo", new getAllInfo()); + processMap.put("getInfoByPlugin", new getInfoByPlugin()); + processMap.put("isCaptchaWaiting", new isCaptchaWaiting()); + processMap.put("getCaptchaTask", new getCaptchaTask()); + processMap.put("getCaptchaTaskStatus", new getCaptchaTaskStatus()); + processMap.put("setCaptchaResult", new setCaptchaResult()); + return processMap; + } + + public static class getConfigValue<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getConfigValue_args, String> { + public getConfigValue() { + super("getConfigValue"); + } + + public getConfigValue_args getEmptyArgsInstance() { + return new getConfigValue_args(); + } + + public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<String>() { + public void onComplete(String o) { + getConfigValue_result result = new getConfigValue_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getConfigValue_result result = new getConfigValue_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getConfigValue_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException { + iface.getConfigValue(args.category, args.option, args.section, resultHandler); + } + } + + public static class setConfigValue<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setConfigValue_args, Void> { + public setConfigValue() { + super("setConfigValue"); + } + + public setConfigValue_args getEmptyArgsInstance() { + return new setConfigValue_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + setConfigValue_result result = new setConfigValue_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + setConfigValue_result result = new setConfigValue_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, setConfigValue_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.setConfigValue(args.category, args.option, args.value, args.section, resultHandler); + } + } + + public static class getConfig<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getConfig_args, Map<String, ConfigSection>> { + public getConfig() { + super("getConfig"); + } + + public getConfig_args getEmptyArgsInstance() { + return new getConfig_args(); + } + + public AsyncMethodCallback<Map<String, ConfigSection>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, ConfigSection>>() { + public void onComplete(Map<String, ConfigSection> o) { + getConfig_result result = new getConfig_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getConfig_result result = new getConfig_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getConfig_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, ConfigSection>> resultHandler) throws TException { + iface.getConfig(resultHandler); + } + } + + public static class getPluginConfig<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getPluginConfig_args, Map<String, ConfigSection>> { + public getPluginConfig() { + super("getPluginConfig"); + } + + public getPluginConfig_args getEmptyArgsInstance() { + return new getPluginConfig_args(); + } + + public AsyncMethodCallback<Map<String, ConfigSection>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, ConfigSection>>() { + public void onComplete(Map<String, ConfigSection> o) { + getPluginConfig_result result = new getPluginConfig_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getPluginConfig_result result = new getPluginConfig_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getPluginConfig_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, ConfigSection>> resultHandler) throws TException { + iface.getPluginConfig(resultHandler); + } + } + + public static class pauseServer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, pauseServer_args, Void> { + public pauseServer() { + super("pauseServer"); + } + + public pauseServer_args getEmptyArgsInstance() { + return new pauseServer_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + pauseServer_result result = new pauseServer_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + pauseServer_result result = new pauseServer_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, pauseServer_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.pauseServer(resultHandler); + } + } + + public static class unpauseServer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, unpauseServer_args, Void> { + public unpauseServer() { + super("unpauseServer"); + } + + public unpauseServer_args getEmptyArgsInstance() { + return new unpauseServer_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + unpauseServer_result result = new unpauseServer_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + unpauseServer_result result = new unpauseServer_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, unpauseServer_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.unpauseServer(resultHandler); + } + } + + public static class togglePause<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, togglePause_args, Boolean> { + public togglePause() { + super("togglePause"); + } + + public togglePause_args getEmptyArgsInstance() { + return new togglePause_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + togglePause_result result = new togglePause_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + togglePause_result result = new togglePause_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, togglePause_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.togglePause(resultHandler); + } + } + + public static class statusServer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, statusServer_args, ServerStatus> { + public statusServer() { + super("statusServer"); + } + + public statusServer_args getEmptyArgsInstance() { + return new statusServer_args(); + } + + public AsyncMethodCallback<ServerStatus> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<ServerStatus>() { + public void onComplete(ServerStatus o) { + statusServer_result result = new statusServer_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + statusServer_result result = new statusServer_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, statusServer_args args, org.apache.thrift.async.AsyncMethodCallback<ServerStatus> resultHandler) throws TException { + iface.statusServer(resultHandler); + } + } + + public static class freeSpace<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, freeSpace_args, Long> { + public freeSpace() { + super("freeSpace"); + } + + public freeSpace_args getEmptyArgsInstance() { + return new freeSpace_args(); + } + + public AsyncMethodCallback<Long> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Long>() { + public void onComplete(Long o) { + freeSpace_result result = new freeSpace_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + freeSpace_result result = new freeSpace_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, freeSpace_args args, org.apache.thrift.async.AsyncMethodCallback<Long> resultHandler) throws TException { + iface.freeSpace(resultHandler); + } + } + + public static class getServerVersion<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getServerVersion_args, String> { + public getServerVersion() { + super("getServerVersion"); + } + + public getServerVersion_args getEmptyArgsInstance() { + return new getServerVersion_args(); + } + + public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<String>() { + public void onComplete(String o) { + getServerVersion_result result = new getServerVersion_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getServerVersion_result result = new getServerVersion_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getServerVersion_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException { + iface.getServerVersion(resultHandler); + } + } + + public static class kill<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, kill_args, Void> { + public kill() { + super("kill"); + } + + public kill_args getEmptyArgsInstance() { + return new kill_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + kill_result result = new kill_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + kill_result result = new kill_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, kill_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.kill(resultHandler); + } + } + + public static class restart<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, restart_args, Void> { + public restart() { + super("restart"); + } + + public restart_args getEmptyArgsInstance() { + return new restart_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + restart_result result = new restart_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + restart_result result = new restart_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, restart_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.restart(resultHandler); + } + } + + public static class getLog<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getLog_args, List<String>> { + public getLog() { + super("getLog"); + } + + public getLog_args getEmptyArgsInstance() { + return new getLog_args(); + } + + public AsyncMethodCallback<List<String>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<String>>() { + public void onComplete(List<String> o) { + getLog_result result = new getLog_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getLog_result result = new getLog_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getLog_args args, org.apache.thrift.async.AsyncMethodCallback<List<String>> resultHandler) throws TException { + iface.getLog(args.offset, resultHandler); + } + } + + public static class isTimeDownload<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTimeDownload_args, Boolean> { + public isTimeDownload() { + super("isTimeDownload"); + } + + public isTimeDownload_args getEmptyArgsInstance() { + return new isTimeDownload_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + isTimeDownload_result result = new isTimeDownload_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + isTimeDownload_result result = new isTimeDownload_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, isTimeDownload_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.isTimeDownload(resultHandler); + } + } + + public static class isTimeReconnect<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isTimeReconnect_args, Boolean> { + public isTimeReconnect() { + super("isTimeReconnect"); + } + + public isTimeReconnect_args getEmptyArgsInstance() { + return new isTimeReconnect_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + isTimeReconnect_result result = new isTimeReconnect_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + isTimeReconnect_result result = new isTimeReconnect_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, isTimeReconnect_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.isTimeReconnect(resultHandler); + } + } + + public static class toggleReconnect<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, toggleReconnect_args, Boolean> { + public toggleReconnect() { + super("toggleReconnect"); + } + + public toggleReconnect_args getEmptyArgsInstance() { + return new toggleReconnect_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + toggleReconnect_result result = new toggleReconnect_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + toggleReconnect_result result = new toggleReconnect_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, toggleReconnect_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.toggleReconnect(resultHandler); + } + } + + public static class generatePackages<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, generatePackages_args, Map<String, List<String>>> { + public generatePackages() { + super("generatePackages"); + } + + public generatePackages_args getEmptyArgsInstance() { + return new generatePackages_args(); + } + + public AsyncMethodCallback<Map<String, List<String>>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, List<String>>>() { + public void onComplete(Map<String, List<String>> o) { + generatePackages_result result = new generatePackages_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + generatePackages_result result = new generatePackages_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, generatePackages_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, List<String>>> resultHandler) throws TException { + iface.generatePackages(args.links, resultHandler); + } + } + + public static class checkURLs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkURLs_args, Map<String, List<String>>> { + public checkURLs() { + super("checkURLs"); + } + + public checkURLs_args getEmptyArgsInstance() { + return new checkURLs_args(); + } + + public AsyncMethodCallback<Map<String, List<String>>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, List<String>>>() { + public void onComplete(Map<String, List<String>> o) { + checkURLs_result result = new checkURLs_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + checkURLs_result result = new checkURLs_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, checkURLs_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, List<String>>> resultHandler) throws TException { + iface.checkURLs(args.urls, resultHandler); + } + } + + public static class parseURLs<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, parseURLs_args, Map<String, List<String>>> { + public parseURLs() { + super("parseURLs"); + } + + public parseURLs_args getEmptyArgsInstance() { + return new parseURLs_args(); + } + + public AsyncMethodCallback<Map<String, List<String>>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, List<String>>>() { + public void onComplete(Map<String, List<String>> o) { + parseURLs_result result = new parseURLs_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + parseURLs_result result = new parseURLs_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, parseURLs_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, List<String>>> resultHandler) throws TException { + iface.parseURLs(args.html, args.url, resultHandler); + } + } + + public static class checkOnlineStatus<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkOnlineStatus_args, OnlineCheck> { + public checkOnlineStatus() { + super("checkOnlineStatus"); + } + + public checkOnlineStatus_args getEmptyArgsInstance() { + return new checkOnlineStatus_args(); + } + + public AsyncMethodCallback<OnlineCheck> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<OnlineCheck>() { + public void onComplete(OnlineCheck o) { + checkOnlineStatus_result result = new checkOnlineStatus_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + checkOnlineStatus_result result = new checkOnlineStatus_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, checkOnlineStatus_args args, org.apache.thrift.async.AsyncMethodCallback<OnlineCheck> resultHandler) throws TException { + iface.checkOnlineStatus(args.urls, resultHandler); + } + } + + public static class checkOnlineStatusContainer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, checkOnlineStatusContainer_args, OnlineCheck> { + public checkOnlineStatusContainer() { + super("checkOnlineStatusContainer"); + } + + public checkOnlineStatusContainer_args getEmptyArgsInstance() { + return new checkOnlineStatusContainer_args(); + } + + public AsyncMethodCallback<OnlineCheck> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<OnlineCheck>() { + public void onComplete(OnlineCheck o) { + checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, checkOnlineStatusContainer_args args, org.apache.thrift.async.AsyncMethodCallback<OnlineCheck> resultHandler) throws TException { + iface.checkOnlineStatusContainer(args.urls, args.filename, args.data, resultHandler); + } + } + + public static class pollResults<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, pollResults_args, OnlineCheck> { + public pollResults() { + super("pollResults"); + } + + public pollResults_args getEmptyArgsInstance() { + return new pollResults_args(); + } + + public AsyncMethodCallback<OnlineCheck> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<OnlineCheck>() { + public void onComplete(OnlineCheck o) { + pollResults_result result = new pollResults_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + pollResults_result result = new pollResults_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, pollResults_args args, org.apache.thrift.async.AsyncMethodCallback<OnlineCheck> resultHandler) throws TException { + iface.pollResults(args.rid, resultHandler); + } + } + + public static class statusDownloads<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, statusDownloads_args, List<DownloadInfo>> { + public statusDownloads() { + super("statusDownloads"); + } + + public statusDownloads_args getEmptyArgsInstance() { + return new statusDownloads_args(); + } + + public AsyncMethodCallback<List<DownloadInfo>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<DownloadInfo>>() { + public void onComplete(List<DownloadInfo> o) { + statusDownloads_result result = new statusDownloads_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + statusDownloads_result result = new statusDownloads_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, statusDownloads_args args, org.apache.thrift.async.AsyncMethodCallback<List<DownloadInfo>> resultHandler) throws TException { + iface.statusDownloads(resultHandler); + } + } + + public static class getPackageData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getPackageData_args, PackageData> { + public getPackageData() { + super("getPackageData"); + } + + public getPackageData_args getEmptyArgsInstance() { + return new getPackageData_args(); + } + + public AsyncMethodCallback<PackageData> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<PackageData>() { + public void onComplete(PackageData o) { + getPackageData_result result = new getPackageData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getPackageData_result result = new getPackageData_result(); + if (e instanceof PackageDoesNotExists) { + result.e = (PackageDoesNotExists) e; + result.setEIsSet(true); + msg = result; + } else { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getPackageData_args args, org.apache.thrift.async.AsyncMethodCallback<PackageData> resultHandler) throws TException { + iface.getPackageData(args.pid, resultHandler); + } + } + + public static class getPackageInfo<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getPackageInfo_args, PackageData> { + public getPackageInfo() { + super("getPackageInfo"); + } + + public getPackageInfo_args getEmptyArgsInstance() { + return new getPackageInfo_args(); + } + + public AsyncMethodCallback<PackageData> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<PackageData>() { + public void onComplete(PackageData o) { + getPackageInfo_result result = new getPackageInfo_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getPackageInfo_result result = new getPackageInfo_result(); + if (e instanceof PackageDoesNotExists) { + result.e = (PackageDoesNotExists) e; + result.setEIsSet(true); + msg = result; + } else { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getPackageInfo_args args, org.apache.thrift.async.AsyncMethodCallback<PackageData> resultHandler) throws TException { + iface.getPackageInfo(args.pid, resultHandler); + } + } + + public static class getFileData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getFileData_args, FileData> { + public getFileData() { + super("getFileData"); + } + + public getFileData_args getEmptyArgsInstance() { + return new getFileData_args(); + } + + public AsyncMethodCallback<FileData> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<FileData>() { + public void onComplete(FileData o) { + getFileData_result result = new getFileData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getFileData_result result = new getFileData_result(); + if (e instanceof FileDoesNotExists) { + result.e = (FileDoesNotExists) e; + result.setEIsSet(true); + msg = result; + } else { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getFileData_args args, org.apache.thrift.async.AsyncMethodCallback<FileData> resultHandler) throws TException { + iface.getFileData(args.fid, resultHandler); + } + } + + public static class getQueue<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getQueue_args, List<PackageData>> { + public getQueue() { + super("getQueue"); + } + + public getQueue_args getEmptyArgsInstance() { + return new getQueue_args(); + } + + public AsyncMethodCallback<List<PackageData>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<PackageData>>() { + public void onComplete(List<PackageData> o) { + getQueue_result result = new getQueue_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getQueue_result result = new getQueue_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getQueue_args args, org.apache.thrift.async.AsyncMethodCallback<List<PackageData>> resultHandler) throws TException { + iface.getQueue(resultHandler); + } + } + + public static class getCollector<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getCollector_args, List<PackageData>> { + public getCollector() { + super("getCollector"); + } + + public getCollector_args getEmptyArgsInstance() { + return new getCollector_args(); + } + + public AsyncMethodCallback<List<PackageData>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<PackageData>>() { + public void onComplete(List<PackageData> o) { + getCollector_result result = new getCollector_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getCollector_result result = new getCollector_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getCollector_args args, org.apache.thrift.async.AsyncMethodCallback<List<PackageData>> resultHandler) throws TException { + iface.getCollector(resultHandler); + } + } + + public static class getQueueData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getQueueData_args, List<PackageData>> { + public getQueueData() { + super("getQueueData"); + } + + public getQueueData_args getEmptyArgsInstance() { + return new getQueueData_args(); + } + + public AsyncMethodCallback<List<PackageData>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<PackageData>>() { + public void onComplete(List<PackageData> o) { + getQueueData_result result = new getQueueData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getQueueData_result result = new getQueueData_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getQueueData_args args, org.apache.thrift.async.AsyncMethodCallback<List<PackageData>> resultHandler) throws TException { + iface.getQueueData(resultHandler); + } + } + + public static class getCollectorData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getCollectorData_args, List<PackageData>> { + public getCollectorData() { + super("getCollectorData"); + } + + public getCollectorData_args getEmptyArgsInstance() { + return new getCollectorData_args(); + } + + public AsyncMethodCallback<List<PackageData>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<PackageData>>() { + public void onComplete(List<PackageData> o) { + getCollectorData_result result = new getCollectorData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getCollectorData_result result = new getCollectorData_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getCollectorData_args args, org.apache.thrift.async.AsyncMethodCallback<List<PackageData>> resultHandler) throws TException { + iface.getCollectorData(resultHandler); + } + } + + public static class getPackageOrder<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getPackageOrder_args, Map<Short, Integer>> { + public getPackageOrder() { + super("getPackageOrder"); + } + + public getPackageOrder_args getEmptyArgsInstance() { + return new getPackageOrder_args(); + } + + public AsyncMethodCallback<Map<Short, Integer>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<Short, Integer>>() { + public void onComplete(Map<Short, Integer> o) { + getPackageOrder_result result = new getPackageOrder_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getPackageOrder_result result = new getPackageOrder_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getPackageOrder_args args, org.apache.thrift.async.AsyncMethodCallback<Map<Short, Integer>> resultHandler) throws TException { + iface.getPackageOrder(args.destination, resultHandler); + } + } + + public static class getFileOrder<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getFileOrder_args, Map<Short, Integer>> { + public getFileOrder() { + super("getFileOrder"); + } + + public getFileOrder_args getEmptyArgsInstance() { + return new getFileOrder_args(); + } + + public AsyncMethodCallback<Map<Short, Integer>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<Short, Integer>>() { + public void onComplete(Map<Short, Integer> o) { + getFileOrder_result result = new getFileOrder_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getFileOrder_result result = new getFileOrder_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getFileOrder_args args, org.apache.thrift.async.AsyncMethodCallback<Map<Short, Integer>> resultHandler) throws TException { + iface.getFileOrder(args.pid, resultHandler); + } + } + + public static class generateAndAddPackages<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, generateAndAddPackages_args, List<Integer>> { + public generateAndAddPackages() { + super("generateAndAddPackages"); + } + + public generateAndAddPackages_args getEmptyArgsInstance() { + return new generateAndAddPackages_args(); + } + + public AsyncMethodCallback<List<Integer>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<Integer>>() { + public void onComplete(List<Integer> o) { + generateAndAddPackages_result result = new generateAndAddPackages_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + generateAndAddPackages_result result = new generateAndAddPackages_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, generateAndAddPackages_args args, org.apache.thrift.async.AsyncMethodCallback<List<Integer>> resultHandler) throws TException { + iface.generateAndAddPackages(args.links, args.dest, resultHandler); + } + } + + public static class addPackage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, addPackage_args, Integer> { + public addPackage() { + super("addPackage"); + } + + public addPackage_args getEmptyArgsInstance() { + return new addPackage_args(); + } + + public AsyncMethodCallback<Integer> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Integer>() { + public void onComplete(Integer o) { + addPackage_result result = new addPackage_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + addPackage_result result = new addPackage_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, addPackage_args args, org.apache.thrift.async.AsyncMethodCallback<Integer> resultHandler) throws TException { + iface.addPackage(args.name, args.links, args.dest, resultHandler); + } + } + + public static class addFiles<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, addFiles_args, Void> { + public addFiles() { + super("addFiles"); + } + + public addFiles_args getEmptyArgsInstance() { + return new addFiles_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + addFiles_result result = new addFiles_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + addFiles_result result = new addFiles_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, addFiles_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.addFiles(args.pid, args.links, resultHandler); + } + } + + public static class uploadContainer<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, uploadContainer_args, Void> { + public uploadContainer() { + super("uploadContainer"); + } + + public uploadContainer_args getEmptyArgsInstance() { + return new uploadContainer_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + uploadContainer_result result = new uploadContainer_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + uploadContainer_result result = new uploadContainer_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, uploadContainer_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.uploadContainer(args.filename, args.data, resultHandler); + } + } + + public static class deleteFiles<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteFiles_args, Void> { + public deleteFiles() { + super("deleteFiles"); + } + + public deleteFiles_args getEmptyArgsInstance() { + return new deleteFiles_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + deleteFiles_result result = new deleteFiles_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + deleteFiles_result result = new deleteFiles_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, deleteFiles_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.deleteFiles(args.fids, resultHandler); + } + } + + public static class deletePackages<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deletePackages_args, Void> { + public deletePackages() { + super("deletePackages"); + } + + public deletePackages_args getEmptyArgsInstance() { + return new deletePackages_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + deletePackages_result result = new deletePackages_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + deletePackages_result result = new deletePackages_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, deletePackages_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.deletePackages(args.pids, resultHandler); + } + } + + public static class pushToQueue<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, pushToQueue_args, Void> { + public pushToQueue() { + super("pushToQueue"); + } + + public pushToQueue_args getEmptyArgsInstance() { + return new pushToQueue_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + pushToQueue_result result = new pushToQueue_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + pushToQueue_result result = new pushToQueue_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, pushToQueue_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.pushToQueue(args.pid, resultHandler); + } + } + + public static class pullFromQueue<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, pullFromQueue_args, Void> { + public pullFromQueue() { + super("pullFromQueue"); + } + + public pullFromQueue_args getEmptyArgsInstance() { + return new pullFromQueue_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + pullFromQueue_result result = new pullFromQueue_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + pullFromQueue_result result = new pullFromQueue_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, pullFromQueue_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.pullFromQueue(args.pid, resultHandler); + } + } + + public static class restartPackage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, restartPackage_args, Void> { + public restartPackage() { + super("restartPackage"); + } + + public restartPackage_args getEmptyArgsInstance() { + return new restartPackage_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + restartPackage_result result = new restartPackage_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + restartPackage_result result = new restartPackage_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, restartPackage_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.restartPackage(args.pid, resultHandler); + } + } + + public static class restartFile<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, restartFile_args, Void> { + public restartFile() { + super("restartFile"); + } + + public restartFile_args getEmptyArgsInstance() { + return new restartFile_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + restartFile_result result = new restartFile_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + restartFile_result result = new restartFile_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, restartFile_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.restartFile(args.fid, resultHandler); + } + } + + public static class recheckPackage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, recheckPackage_args, Void> { + public recheckPackage() { + super("recheckPackage"); + } + + public recheckPackage_args getEmptyArgsInstance() { + return new recheckPackage_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + recheckPackage_result result = new recheckPackage_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + recheckPackage_result result = new recheckPackage_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, recheckPackage_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.recheckPackage(args.pid, resultHandler); + } + } + + public static class stopAllDownloads<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, stopAllDownloads_args, Void> { + public stopAllDownloads() { + super("stopAllDownloads"); + } + + public stopAllDownloads_args getEmptyArgsInstance() { + return new stopAllDownloads_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + stopAllDownloads_result result = new stopAllDownloads_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + stopAllDownloads_result result = new stopAllDownloads_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, stopAllDownloads_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.stopAllDownloads(resultHandler); + } + } + + public static class stopDownloads<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, stopDownloads_args, Void> { + public stopDownloads() { + super("stopDownloads"); + } + + public stopDownloads_args getEmptyArgsInstance() { + return new stopDownloads_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + stopDownloads_result result = new stopDownloads_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + stopDownloads_result result = new stopDownloads_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, stopDownloads_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.stopDownloads(args.fids, resultHandler); + } + } + + public static class setPackageName<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setPackageName_args, Void> { + public setPackageName() { + super("setPackageName"); + } + + public setPackageName_args getEmptyArgsInstance() { + return new setPackageName_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + setPackageName_result result = new setPackageName_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + setPackageName_result result = new setPackageName_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, setPackageName_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.setPackageName(args.pid, args.name, resultHandler); + } + } + + public static class movePackage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, movePackage_args, Void> { + public movePackage() { + super("movePackage"); + } + + public movePackage_args getEmptyArgsInstance() { + return new movePackage_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + movePackage_result result = new movePackage_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + movePackage_result result = new movePackage_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, movePackage_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.movePackage(args.destination, args.pid, resultHandler); + } + } + + public static class moveFiles<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, moveFiles_args, Void> { + public moveFiles() { + super("moveFiles"); + } + + public moveFiles_args getEmptyArgsInstance() { + return new moveFiles_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + moveFiles_result result = new moveFiles_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + moveFiles_result result = new moveFiles_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, moveFiles_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.moveFiles(args.fids, args.pid, resultHandler); + } + } + + public static class orderPackage<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, orderPackage_args, Void> { + public orderPackage() { + super("orderPackage"); + } + + public orderPackage_args getEmptyArgsInstance() { + return new orderPackage_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + orderPackage_result result = new orderPackage_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + orderPackage_result result = new orderPackage_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, orderPackage_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.orderPackage(args.pid, args.position, resultHandler); + } + } + + public static class orderFile<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, orderFile_args, Void> { + public orderFile() { + super("orderFile"); + } + + public orderFile_args getEmptyArgsInstance() { + return new orderFile_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + orderFile_result result = new orderFile_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + orderFile_result result = new orderFile_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, orderFile_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.orderFile(args.fid, args.position, resultHandler); + } + } + + public static class setPackageData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setPackageData_args, Void> { + public setPackageData() { + super("setPackageData"); + } + + public setPackageData_args getEmptyArgsInstance() { + return new setPackageData_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + setPackageData_result result = new setPackageData_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + setPackageData_result result = new setPackageData_result(); + if (e instanceof PackageDoesNotExists) { + result.e = (PackageDoesNotExists) e; + result.setEIsSet(true); + msg = result; + } else { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, setPackageData_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.setPackageData(args.pid, args.data, resultHandler); + } + } + + public static class deleteFinished<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, deleteFinished_args, List<Integer>> { + public deleteFinished() { + super("deleteFinished"); + } + + public deleteFinished_args getEmptyArgsInstance() { + return new deleteFinished_args(); + } + + public AsyncMethodCallback<List<Integer>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<Integer>>() { + public void onComplete(List<Integer> o) { + deleteFinished_result result = new deleteFinished_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + deleteFinished_result result = new deleteFinished_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, deleteFinished_args args, org.apache.thrift.async.AsyncMethodCallback<List<Integer>> resultHandler) throws TException { + iface.deleteFinished(resultHandler); + } + } + + public static class restartFailed<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, restartFailed_args, Void> { + public restartFailed() { + super("restartFailed"); + } + + public restartFailed_args getEmptyArgsInstance() { + return new restartFailed_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + restartFailed_result result = new restartFailed_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + restartFailed_result result = new restartFailed_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, restartFailed_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.restartFailed(resultHandler); + } + } + + public static class getEvents<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getEvents_args, List<EventInfo>> { + public getEvents() { + super("getEvents"); + } + + public getEvents_args getEmptyArgsInstance() { + return new getEvents_args(); + } + + public AsyncMethodCallback<List<EventInfo>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<EventInfo>>() { + public void onComplete(List<EventInfo> o) { + getEvents_result result = new getEvents_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getEvents_result result = new getEvents_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getEvents_args args, org.apache.thrift.async.AsyncMethodCallback<List<EventInfo>> resultHandler) throws TException { + iface.getEvents(args.uuid, resultHandler); + } + } + + public static class getAccounts<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAccounts_args, List<AccountInfo>> { + public getAccounts() { + super("getAccounts"); + } + + public getAccounts_args getEmptyArgsInstance() { + return new getAccounts_args(); + } + + public AsyncMethodCallback<List<AccountInfo>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<AccountInfo>>() { + public void onComplete(List<AccountInfo> o) { + getAccounts_result result = new getAccounts_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getAccounts_result result = new getAccounts_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getAccounts_args args, org.apache.thrift.async.AsyncMethodCallback<List<AccountInfo>> resultHandler) throws TException { + iface.getAccounts(args.refresh, resultHandler); + } + } + + public static class getAccountTypes<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAccountTypes_args, List<String>> { + public getAccountTypes() { + super("getAccountTypes"); + } + + public getAccountTypes_args getEmptyArgsInstance() { + return new getAccountTypes_args(); + } + + public AsyncMethodCallback<List<String>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<List<String>>() { + public void onComplete(List<String> o) { + getAccountTypes_result result = new getAccountTypes_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getAccountTypes_result result = new getAccountTypes_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getAccountTypes_args args, org.apache.thrift.async.AsyncMethodCallback<List<String>> resultHandler) throws TException { + iface.getAccountTypes(resultHandler); + } + } + + public static class updateAccount<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, updateAccount_args, Void> { + public updateAccount() { + super("updateAccount"); + } + + public updateAccount_args getEmptyArgsInstance() { + return new updateAccount_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + updateAccount_result result = new updateAccount_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + updateAccount_result result = new updateAccount_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, updateAccount_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.updateAccount(args.plugin, args.account, args.password, args.options, resultHandler); + } + } + + public static class removeAccount<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, removeAccount_args, Void> { + public removeAccount() { + super("removeAccount"); + } + + public removeAccount_args getEmptyArgsInstance() { + return new removeAccount_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + removeAccount_result result = new removeAccount_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + removeAccount_result result = new removeAccount_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, removeAccount_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.removeAccount(args.plugin, args.account, resultHandler); + } + } + + public static class login<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, login_args, Boolean> { + public login() { + super("login"); + } + + public login_args getEmptyArgsInstance() { + return new login_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + login_result result = new login_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + login_result result = new login_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, login_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.login(args.username, args.password, resultHandler); + } + } + + public static class getUserData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getUserData_args, UserData> { + public getUserData() { + super("getUserData"); + } + + public getUserData_args getEmptyArgsInstance() { + return new getUserData_args(); + } + + public AsyncMethodCallback<UserData> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<UserData>() { + public void onComplete(UserData o) { + getUserData_result result = new getUserData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getUserData_result result = new getUserData_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getUserData_args args, org.apache.thrift.async.AsyncMethodCallback<UserData> resultHandler) throws TException { + iface.getUserData(args.username, args.password, resultHandler); + } + } + + public static class getAllUserData<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAllUserData_args, Map<String, UserData>> { + public getAllUserData() { + super("getAllUserData"); + } + + public getAllUserData_args getEmptyArgsInstance() { + return new getAllUserData_args(); + } + + public AsyncMethodCallback<Map<String, UserData>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, UserData>>() { + public void onComplete(Map<String, UserData> o) { + getAllUserData_result result = new getAllUserData_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getAllUserData_result result = new getAllUserData_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getAllUserData_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, UserData>> resultHandler) throws TException { + iface.getAllUserData(resultHandler); + } + } + + public static class getServices<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getServices_args, Map<String, Map<String, String>>> { + public getServices() { + super("getServices"); + } + + public getServices_args getEmptyArgsInstance() { + return new getServices_args(); + } + + public AsyncMethodCallback<Map<String, Map<String, String>>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, Map<String, String>>>() { + public void onComplete(Map<String, Map<String, String>> o) { + getServices_result result = new getServices_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getServices_result result = new getServices_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getServices_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, Map<String, String>>> resultHandler) throws TException { + iface.getServices(resultHandler); + } + } + + public static class hasService<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, hasService_args, Boolean> { + public hasService() { + super("hasService"); + } + + public hasService_args getEmptyArgsInstance() { + return new hasService_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + hasService_result result = new hasService_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + hasService_result result = new hasService_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, hasService_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.hasService(args.plugin, args.func, resultHandler); + } + } + + public static class call<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, call_args, String> { + public call() { + super("call"); + } + + public call_args getEmptyArgsInstance() { + return new call_args(); + } + + public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<String>() { + public void onComplete(String o) { + call_result result = new call_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + call_result result = new call_result(); + if (e instanceof ServiceDoesNotExists) { + result.ex = (ServiceDoesNotExists) e; + result.setExIsSet(true); + msg = result; + } else if (e instanceof ServiceException) { + result.e = (ServiceException) e; + result.setEIsSet(true); + msg = result; + } else { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, call_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException { + iface.call(args.info, resultHandler); + } + } + + public static class getAllInfo<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getAllInfo_args, Map<String, Map<String, String>>> { + public getAllInfo() { + super("getAllInfo"); + } + + public getAllInfo_args getEmptyArgsInstance() { + return new getAllInfo_args(); + } + + public AsyncMethodCallback<Map<String, Map<String, String>>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, Map<String, String>>>() { + public void onComplete(Map<String, Map<String, String>> o) { + getAllInfo_result result = new getAllInfo_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getAllInfo_result result = new getAllInfo_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getAllInfo_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, Map<String, String>>> resultHandler) throws TException { + iface.getAllInfo(resultHandler); + } + } + + public static class getInfoByPlugin<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getInfoByPlugin_args, Map<String, String>> { + public getInfoByPlugin() { + super("getInfoByPlugin"); + } + + public getInfoByPlugin_args getEmptyArgsInstance() { + return new getInfoByPlugin_args(); + } + + public AsyncMethodCallback<Map<String, String>> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Map<String, String>>() { + public void onComplete(Map<String, String> o) { + getInfoByPlugin_result result = new getInfoByPlugin_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getInfoByPlugin_result result = new getInfoByPlugin_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getInfoByPlugin_args args, org.apache.thrift.async.AsyncMethodCallback<Map<String, String>> resultHandler) throws TException { + iface.getInfoByPlugin(args.plugin, resultHandler); + } + } + + public static class isCaptchaWaiting<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, isCaptchaWaiting_args, Boolean> { + public isCaptchaWaiting() { + super("isCaptchaWaiting"); + } + + public isCaptchaWaiting_args getEmptyArgsInstance() { + return new isCaptchaWaiting_args(); + } + + public AsyncMethodCallback<Boolean> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Boolean>() { + public void onComplete(Boolean o) { + isCaptchaWaiting_result result = new isCaptchaWaiting_result(); + result.success = o; + result.setSuccessIsSet(true); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + isCaptchaWaiting_result result = new isCaptchaWaiting_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, isCaptchaWaiting_args args, org.apache.thrift.async.AsyncMethodCallback<Boolean> resultHandler) throws TException { + iface.isCaptchaWaiting(resultHandler); + } + } + + public static class getCaptchaTask<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getCaptchaTask_args, CaptchaTask> { + public getCaptchaTask() { + super("getCaptchaTask"); + } + + public getCaptchaTask_args getEmptyArgsInstance() { + return new getCaptchaTask_args(); + } + + public AsyncMethodCallback<CaptchaTask> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<CaptchaTask>() { + public void onComplete(CaptchaTask o) { + getCaptchaTask_result result = new getCaptchaTask_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getCaptchaTask_result result = new getCaptchaTask_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getCaptchaTask_args args, org.apache.thrift.async.AsyncMethodCallback<CaptchaTask> resultHandler) throws TException { + iface.getCaptchaTask(args.exclusive, resultHandler); + } + } + + public static class getCaptchaTaskStatus<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, getCaptchaTaskStatus_args, String> { + public getCaptchaTaskStatus() { + super("getCaptchaTaskStatus"); + } + + public getCaptchaTaskStatus_args getEmptyArgsInstance() { + return new getCaptchaTaskStatus_args(); + } + + public AsyncMethodCallback<String> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<String>() { + public void onComplete(String o) { + getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); + result.success = o; + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, getCaptchaTaskStatus_args args, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws TException { + iface.getCaptchaTaskStatus(args.tid, resultHandler); + } + } + + public static class setCaptchaResult<I extends AsyncIface> extends org.apache.thrift.AsyncProcessFunction<I, setCaptchaResult_args, Void> { + public setCaptchaResult() { + super("setCaptchaResult"); + } + + public setCaptchaResult_args getEmptyArgsInstance() { + return new setCaptchaResult_args(); + } + + public AsyncMethodCallback<Void> getResultHandler(final AsyncFrameBuffer fb, final int seqid) { + final org.apache.thrift.AsyncProcessFunction fcall = this; + return new AsyncMethodCallback<Void>() { + public void onComplete(Void o) { + setCaptchaResult_result result = new setCaptchaResult_result(); + try { + fcall.sendResponse(fb, result, org.apache.thrift.protocol.TMessageType.REPLY, seqid); + return; + } catch (Exception e) { + LOGGER.error("Exception writing to internal frame buffer", e); + } + fb.close(); + } + + public void onError(Exception e) { + byte msgType = org.apache.thrift.protocol.TMessageType.REPLY; + org.apache.thrift.TBase msg; + setCaptchaResult_result result = new setCaptchaResult_result(); + { + msgType = org.apache.thrift.protocol.TMessageType.EXCEPTION; + msg = (org.apache.thrift.TBase) new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.INTERNAL_ERROR, e.getMessage()); + } + try { + fcall.sendResponse(fb, msg, msgType, seqid); + return; + } catch (Exception ex) { + LOGGER.error("Exception writing to internal frame buffer", ex); + } + fb.close(); + } + }; + } + + protected boolean isOneway() { + return false; + } + + public void start(I iface, setCaptchaResult_args args, org.apache.thrift.async.AsyncMethodCallback<Void> resultHandler) throws TException { + iface.setCaptchaResult(args.tid, args.result, resultHandler); + } + } + + } + + public static class getConfigValue_args implements org.apache.thrift.TBase<getConfigValue_args, getConfigValue_args._Fields>, java.io.Serializable, Cloneable, Comparable<getConfigValue_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfigValue_args"); + + private static final org.apache.thrift.protocol.TField CATEGORY_FIELD_DESC = new org.apache.thrift.protocol.TField("category", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField OPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("option", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField SECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("section", org.apache.thrift.protocol.TType.STRING, (short) 3); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getConfigValue_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getConfigValue_argsTupleSchemeFactory()); + } + + public String category; // required + public String option; // required + public String section; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(category); + out.writeString(option); + out.writeString(section); + } + + @Override + public int describeContents() { + return 0; + } + + public getConfigValue_args(android.os.Parcel in) { + this.category = in.readString(); + this.option = in.readString(); + this.section = in.readString(); + } + + public static final android.os.Parcelable.Creator<getConfigValue_args> CREATOR = new android.os.Parcelable.Creator<getConfigValue_args>() { + @Override + public getConfigValue_args[] newArray(int size) { + return new getConfigValue_args[size]; + } + + @Override + public getConfigValue_args createFromParcel(android.os.Parcel in) { + return new getConfigValue_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + CATEGORY((short) 1, "category"), + OPTION((short) 2, "option"), + SECTION((short) 3, "section"); + + 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: // CATEGORY + return CATEGORY; + case 2: // OPTION + return OPTION; + case 3: // SECTION + return SECTION; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.CATEGORY, new org.apache.thrift.meta_data.FieldMetaData("category", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OPTION, new org.apache.thrift.meta_data.FieldMetaData("option", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.SECTION, new org.apache.thrift.meta_data.FieldMetaData("section", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfigValue_args.class, metaDataMap); + } + + public getConfigValue_args() { + } + + public getConfigValue_args( + String category, + String option, + String section) { + this(); + this.category = category; + this.option = option; + this.section = section; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getConfigValue_args(getConfigValue_args other) { + if (other.isSetCategory()) { + this.category = other.category; + } + if (other.isSetOption()) { + this.option = other.option; + } + if (other.isSetSection()) { + this.section = other.section; + } + } + + public getConfigValue_args deepCopy() { + return new getConfigValue_args(this); + } + + @Override + public void clear() { + this.category = null; + this.option = null; + this.section = null; + } + + public String getCategory() { + return this.category; + } + + public getConfigValue_args setCategory(String category) { + this.category = category; + return this; + } + + public void unsetCategory() { + this.category = null; + } + + /** Returns true if field category is set (has been assigned a value) and false otherwise */ + public boolean isSetCategory() { + return this.category != null; + } + + public void setCategoryIsSet(boolean value) { + if (!value) { + this.category = null; + } + } + + public String getOption() { + return this.option; + } + + public getConfigValue_args setOption(String option) { + this.option = option; + return this; + } + + public void unsetOption() { + this.option = null; + } + + /** Returns true if field option is set (has been assigned a value) and false otherwise */ + public boolean isSetOption() { + return this.option != null; + } + + public void setOptionIsSet(boolean value) { + if (!value) { + this.option = null; + } + } + + public String getSection() { + return this.section; + } + + public getConfigValue_args setSection(String section) { + this.section = section; + return this; + } + + public void unsetSection() { + this.section = null; + } + + /** Returns true if field section is set (has been assigned a value) and false otherwise */ + public boolean isSetSection() { + return this.section != null; + } + + public void setSectionIsSet(boolean value) { + if (!value) { + this.section = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case CATEGORY: + if (value == null) { + unsetCategory(); + } else { + setCategory((String) value); + } + break; + + case OPTION: + if (value == null) { + unsetOption(); + } else { + setOption((String) value); + } + break; + + case SECTION: + if (value == null) { + unsetSection(); + } else { + setSection((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case CATEGORY: + return getCategory(); + + case OPTION: + return getOption(); + + case SECTION: + return getSection(); + + } + 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 CATEGORY: + return isSetCategory(); + case OPTION: + return isSetOption(); + case SECTION: + return isSetSection(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getConfigValue_args) + return this.equals((getConfigValue_args) that); + return false; + } + + public boolean equals(getConfigValue_args that) { + if (that == null) + return false; + + boolean this_present_category = true && this.isSetCategory(); + boolean that_present_category = true && that.isSetCategory(); + if (this_present_category || that_present_category) { + if (!(this_present_category && that_present_category)) + return false; + if (!this.category.equals(that.category)) + return false; + } + + boolean this_present_option = true && this.isSetOption(); + boolean that_present_option = true && that.isSetOption(); + if (this_present_option || that_present_option) { + if (!(this_present_option && that_present_option)) + return false; + if (!this.option.equals(that.option)) + return false; + } + + boolean this_present_section = true && this.isSetSection(); + boolean that_present_section = true && that.isSetSection(); + if (this_present_section || that_present_section) { + if (!(this_present_section && that_present_section)) + return false; + if (!this.section.equals(that.section)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_category = true && (isSetCategory()); + list.add(present_category); + if (present_category) + list.add(category); + + boolean present_option = true && (isSetOption()); + list.add(present_option); + if (present_option) + list.add(option); + + boolean present_section = true && (isSetSection()); + list.add(present_section); + if (present_section) + list.add(section); + + return list.hashCode(); + } + + @Override + public int compareTo(getConfigValue_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetCategory()).compareTo(other.isSetCategory()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCategory()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.category, other.category); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOption()).compareTo(other.isSetOption()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOption()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.option, other.option); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetSection()).compareTo(other.isSetSection()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSection()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.section, other.section); + 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("getConfigValue_args("); + boolean first = true; + + sb.append("category:"); + if (this.category == null) { + sb.append("null"); + } else { + sb.append(this.category); + } + first = false; + if (!first) sb.append(", "); + sb.append("option:"); + if (this.option == null) { + sb.append("null"); + } else { + sb.append(this.option); + } + first = false; + if (!first) sb.append(", "); + sb.append("section:"); + if (this.section == null) { + sb.append("null"); + } else { + sb.append(this.section); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class getConfigValue_argsStandardSchemeFactory implements SchemeFactory { + public getConfigValue_argsStandardScheme getScheme() { + return new getConfigValue_argsStandardScheme(); + } + } + + private static class getConfigValue_argsStandardScheme extends StandardScheme<getConfigValue_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getConfigValue_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: // CATEGORY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.category = iprot.readString(); + struct.setCategoryIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // OPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.option = iprot.readString(); + struct.setOptionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // SECTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.section = iprot.readString(); + struct.setSectionIsSet(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, getConfigValue_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.category != null) { + oprot.writeFieldBegin(CATEGORY_FIELD_DESC); + oprot.writeString(struct.category); + oprot.writeFieldEnd(); + } + if (struct.option != null) { + oprot.writeFieldBegin(OPTION_FIELD_DESC); + oprot.writeString(struct.option); + oprot.writeFieldEnd(); + } + if (struct.section != null) { + oprot.writeFieldBegin(SECTION_FIELD_DESC); + oprot.writeString(struct.section); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getConfigValue_argsTupleSchemeFactory implements SchemeFactory { + public getConfigValue_argsTupleScheme getScheme() { + return new getConfigValue_argsTupleScheme(); + } + } + + private static class getConfigValue_argsTupleScheme extends TupleScheme<getConfigValue_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getConfigValue_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetCategory()) { + optionals.set(0); + } + if (struct.isSetOption()) { + optionals.set(1); + } + if (struct.isSetSection()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetCategory()) { + oprot.writeString(struct.category); + } + if (struct.isSetOption()) { + oprot.writeString(struct.option); + } + if (struct.isSetSection()) { + oprot.writeString(struct.section); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getConfigValue_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.category = iprot.readString(); + struct.setCategoryIsSet(true); + } + if (incoming.get(1)) { + struct.option = iprot.readString(); + struct.setOptionIsSet(true); + } + if (incoming.get(2)) { + struct.section = iprot.readString(); + struct.setSectionIsSet(true); + } + } + } + + } + + public static class getConfigValue_result implements org.apache.thrift.TBase<getConfigValue_result, getConfigValue_result._Fields>, java.io.Serializable, Cloneable, Comparable<getConfigValue_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfigValue_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getConfigValue_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getConfigValue_resultTupleSchemeFactory()); + } + + public String success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(success); + } + + @Override + public int describeContents() { + return 0; + } + + public getConfigValue_result(android.os.Parcel in) { + this.success = in.readString(); + } + + public static final android.os.Parcelable.Creator<getConfigValue_result> CREATOR = new android.os.Parcelable.Creator<getConfigValue_result>() { + @Override + public getConfigValue_result[] newArray(int size) { + return new getConfigValue_result[size]; + } + + @Override + public getConfigValue_result createFromParcel(android.os.Parcel in) { + return new getConfigValue_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfigValue_result.class, metaDataMap); + } + + public getConfigValue_result() { + } + + public getConfigValue_result( + String success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getConfigValue_result(getConfigValue_result other) { + if (other.isSetSuccess()) { + this.success = other.success; + } + } + + public getConfigValue_result deepCopy() { + return new getConfigValue_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public String getSuccess() { + return this.success; + } + + public getConfigValue_result setSuccess(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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getConfigValue_result) + return this.equals((getConfigValue_result) that); + return false; + } + + public boolean equals(getConfigValue_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(getConfigValue_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("getConfigValue_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, 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 getConfigValue_resultStandardSchemeFactory implements SchemeFactory { + public getConfigValue_resultStandardScheme getScheme() { + return new getConfigValue_resultStandardScheme(); + } + } + + private static class getConfigValue_resultStandardScheme extends StandardScheme<getConfigValue_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getConfigValue_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, getConfigValue_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 getConfigValue_resultTupleSchemeFactory implements SchemeFactory { + public getConfigValue_resultTupleScheme getScheme() { + return new getConfigValue_resultTupleScheme(); + } + } + + private static class getConfigValue_resultTupleScheme extends TupleScheme<getConfigValue_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getConfigValue_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new 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, getConfigValue_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readString(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class setConfigValue_args implements org.apache.thrift.TBase<setConfigValue_args, setConfigValue_args._Fields>, java.io.Serializable, Cloneable, Comparable<setConfigValue_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setConfigValue_args"); + + private static final org.apache.thrift.protocol.TField CATEGORY_FIELD_DESC = new org.apache.thrift.protocol.TField("category", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField OPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("option", 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 SECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("section", org.apache.thrift.protocol.TType.STRING, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new setConfigValue_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setConfigValue_argsTupleSchemeFactory()); + } + + public String category; // required + public String option; // required + public String value; // required + public String section; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(category); + out.writeString(option); + out.writeString(value); + out.writeString(section); + } + + @Override + public int describeContents() { + return 0; + } + + public setConfigValue_args(android.os.Parcel in) { + this.category = in.readString(); + this.option = in.readString(); + this.value = in.readString(); + this.section = in.readString(); + } + + public static final android.os.Parcelable.Creator<setConfigValue_args> CREATOR = new android.os.Parcelable.Creator<setConfigValue_args>() { + @Override + public setConfigValue_args[] newArray(int size) { + return new setConfigValue_args[size]; + } + + @Override + public setConfigValue_args createFromParcel(android.os.Parcel in) { + return new setConfigValue_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + CATEGORY((short) 1, "category"), + OPTION((short) 2, "option"), + VALUE((short) 3, "value"), + SECTION((short) 4, "section"); + + 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: // CATEGORY + return CATEGORY; + case 2: // OPTION + return OPTION; + case 3: // VALUE + return VALUE; + case 4: // SECTION + return SECTION; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.CATEGORY, new org.apache.thrift.meta_data.FieldMetaData("category", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OPTION, new org.apache.thrift.meta_data.FieldMetaData("option", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + 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))); + tmpMap.put(_Fields.SECTION, new org.apache.thrift.meta_data.FieldMetaData("section", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setConfigValue_args.class, metaDataMap); + } + + public setConfigValue_args() { + } + + public setConfigValue_args( + String category, + String option, + String value, + String section) { + this(); + this.category = category; + this.option = option; + this.value = value; + this.section = section; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public setConfigValue_args(setConfigValue_args other) { + if (other.isSetCategory()) { + this.category = other.category; + } + if (other.isSetOption()) { + this.option = other.option; + } + if (other.isSetValue()) { + this.value = other.value; + } + if (other.isSetSection()) { + this.section = other.section; + } + } + + public setConfigValue_args deepCopy() { + return new setConfigValue_args(this); + } + + @Override + public void clear() { + this.category = null; + this.option = null; + this.value = null; + this.section = null; + } + + public String getCategory() { + return this.category; + } + + public setConfigValue_args setCategory(String category) { + this.category = category; + return this; + } + + public void unsetCategory() { + this.category = null; + } + + /** Returns true if field category is set (has been assigned a value) and false otherwise */ + public boolean isSetCategory() { + return this.category != null; + } + + public void setCategoryIsSet(boolean value) { + if (!value) { + this.category = null; + } + } + + public String getOption() { + return this.option; + } + + public setConfigValue_args setOption(String option) { + this.option = option; + return this; + } + + public void unsetOption() { + this.option = null; + } + + /** Returns true if field option is set (has been assigned a value) and false otherwise */ + public boolean isSetOption() { + return this.option != null; + } + + public void setOptionIsSet(boolean value) { + if (!value) { + this.option = null; + } + } + + public String getValue() { + return this.value; + } + + public setConfigValue_args setValue(String value) { + this.value = 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 String getSection() { + return this.section; + } + + public setConfigValue_args setSection(String section) { + this.section = section; + return this; + } + + public void unsetSection() { + this.section = null; + } + + /** Returns true if field section is set (has been assigned a value) and false otherwise */ + public boolean isSetSection() { + return this.section != null; + } + + public void setSectionIsSet(boolean value) { + if (!value) { + this.section = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case CATEGORY: + if (value == null) { + unsetCategory(); + } else { + setCategory((String) value); + } + break; + + case OPTION: + if (value == null) { + unsetOption(); + } else { + setOption((String) value); + } + break; + + case VALUE: + if (value == null) { + unsetValue(); + } else { + setValue((String) value); + } + break; + + case SECTION: + if (value == null) { + unsetSection(); + } else { + setSection((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case CATEGORY: + return getCategory(); + + case OPTION: + return getOption(); + + case VALUE: + return getValue(); + + case SECTION: + return getSection(); + + } + 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 CATEGORY: + return isSetCategory(); + case OPTION: + return isSetOption(); + case VALUE: + return isSetValue(); + case SECTION: + return isSetSection(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setConfigValue_args) + return this.equals((setConfigValue_args) that); + return false; + } + + public boolean equals(setConfigValue_args that) { + if (that == null) + return false; + + boolean this_present_category = true && this.isSetCategory(); + boolean that_present_category = true && that.isSetCategory(); + if (this_present_category || that_present_category) { + if (!(this_present_category && that_present_category)) + return false; + if (!this.category.equals(that.category)) + return false; + } + + boolean this_present_option = true && this.isSetOption(); + boolean that_present_option = true && that.isSetOption(); + if (this_present_option || that_present_option) { + if (!(this_present_option && that_present_option)) + return false; + if (!this.option.equals(that.option)) + 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_section = true && this.isSetSection(); + boolean that_present_section = true && that.isSetSection(); + if (this_present_section || that_present_section) { + if (!(this_present_section && that_present_section)) + return false; + if (!this.section.equals(that.section)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_category = true && (isSetCategory()); + list.add(present_category); + if (present_category) + list.add(category); + + boolean present_option = true && (isSetOption()); + list.add(present_option); + if (present_option) + list.add(option); + + boolean present_value = true && (isSetValue()); + list.add(present_value); + if (present_value) + list.add(value); + + boolean present_section = true && (isSetSection()); + list.add(present_section); + if (present_section) + list.add(section); + + return list.hashCode(); + } + + @Override + public int compareTo(setConfigValue_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetCategory()).compareTo(other.isSetCategory()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetCategory()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.category, other.category); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOption()).compareTo(other.isSetOption()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOption()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.option, other.option); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetValue()).compareTo(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 = Boolean.valueOf(isSetSection()).compareTo(other.isSetSection()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSection()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.section, other.section); + 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("setConfigValue_args("); + boolean first = true; + + sb.append("category:"); + if (this.category == null) { + sb.append("null"); + } else { + sb.append(this.category); + } + first = false; + if (!first) sb.append(", "); + sb.append("option:"); + if (this.option == null) { + sb.append("null"); + } else { + sb.append(this.option); + } + first = false; + if (!first) sb.append(", "); + sb.append("value:"); + if (this.value == null) { + sb.append("null"); + } else { + sb.append(this.value); + } + first = false; + if (!first) sb.append(", "); + sb.append("section:"); + if (this.section == null) { + sb.append("null"); + } else { + sb.append(this.section); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class setConfigValue_argsStandardSchemeFactory implements SchemeFactory { + public setConfigValue_argsStandardScheme getScheme() { + return new setConfigValue_argsStandardScheme(); + } + } + + private static class setConfigValue_argsStandardScheme extends StandardScheme<setConfigValue_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, setConfigValue_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: // CATEGORY + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.category = iprot.readString(); + struct.setCategoryIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // OPTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.option = iprot.readString(); + struct.setOptionIsSet(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.readString(); + struct.setValueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // SECTION + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.section = iprot.readString(); + struct.setSectionIsSet(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, setConfigValue_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.category != null) { + oprot.writeFieldBegin(CATEGORY_FIELD_DESC); + oprot.writeString(struct.category); + oprot.writeFieldEnd(); + } + if (struct.option != null) { + oprot.writeFieldBegin(OPTION_FIELD_DESC); + oprot.writeString(struct.option); + oprot.writeFieldEnd(); + } + if (struct.value != null) { + oprot.writeFieldBegin(VALUE_FIELD_DESC); + oprot.writeString(struct.value); + oprot.writeFieldEnd(); + } + if (struct.section != null) { + oprot.writeFieldBegin(SECTION_FIELD_DESC); + oprot.writeString(struct.section); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class setConfigValue_argsTupleSchemeFactory implements SchemeFactory { + public setConfigValue_argsTupleScheme getScheme() { + return new setConfigValue_argsTupleScheme(); + } + } + + private static class setConfigValue_argsTupleScheme extends TupleScheme<setConfigValue_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setConfigValue_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetCategory()) { + optionals.set(0); + } + if (struct.isSetOption()) { + optionals.set(1); + } + if (struct.isSetValue()) { + optionals.set(2); + } + if (struct.isSetSection()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetCategory()) { + oprot.writeString(struct.category); + } + if (struct.isSetOption()) { + oprot.writeString(struct.option); + } + if (struct.isSetValue()) { + oprot.writeString(struct.value); + } + if (struct.isSetSection()) { + oprot.writeString(struct.section); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setConfigValue_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.category = iprot.readString(); + struct.setCategoryIsSet(true); + } + if (incoming.get(1)) { + struct.option = iprot.readString(); + struct.setOptionIsSet(true); + } + if (incoming.get(2)) { + struct.value = iprot.readString(); + struct.setValueIsSet(true); + } + if (incoming.get(3)) { + struct.section = iprot.readString(); + struct.setSectionIsSet(true); + } + } + } + + } + + public static class setConfigValue_result implements org.apache.thrift.TBase<setConfigValue_result, setConfigValue_result._Fields>, java.io.Serializable, Cloneable, Comparable<setConfigValue_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setConfigValue_result"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new setConfigValue_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setConfigValue_resultTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public setConfigValue_result(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<setConfigValue_result> CREATOR = new android.os.Parcelable.Creator<setConfigValue_result>() { + @Override + public setConfigValue_result[] newArray(int size) { + return new setConfigValue_result[size]; + } + + @Override + public setConfigValue_result createFromParcel(android.os.Parcel in) { + return new setConfigValue_result(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setConfigValue_result.class, metaDataMap); + } + + public setConfigValue_result() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public setConfigValue_result(setConfigValue_result other) { + } + + public setConfigValue_result deepCopy() { + return new setConfigValue_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setConfigValue_result) + return this.equals((setConfigValue_result) that); + return false; + } + + public boolean equals(setConfigValue_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(setConfigValue_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("setConfigValue_result("); + 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, 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 setConfigValue_resultStandardSchemeFactory implements SchemeFactory { + public setConfigValue_resultStandardScheme getScheme() { + return new setConfigValue_resultStandardScheme(); + } + } + + private static class setConfigValue_resultStandardScheme extends StandardScheme<setConfigValue_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, setConfigValue_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) { + 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, setConfigValue_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class setConfigValue_resultTupleSchemeFactory implements SchemeFactory { + public setConfigValue_resultTupleScheme getScheme() { + return new setConfigValue_resultTupleScheme(); + } + } + + private static class setConfigValue_resultTupleScheme extends TupleScheme<setConfigValue_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setConfigValue_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setConfigValue_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class getConfig_args implements org.apache.thrift.TBase<getConfig_args, getConfig_args._Fields>, java.io.Serializable, Cloneable, Comparable<getConfig_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfig_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getConfig_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getConfig_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public getConfig_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<getConfig_args> CREATOR = new android.os.Parcelable.Creator<getConfig_args>() { + @Override + public getConfig_args[] newArray(int size) { + return new getConfig_args[size]; + } + + @Override + public getConfig_args createFromParcel(android.os.Parcel in) { + return new getConfig_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfig_args.class, metaDataMap); + } + + public getConfig_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getConfig_args(getConfig_args other) { + } + + public getConfig_args deepCopy() { + return new getConfig_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getConfig_args) + return this.equals((getConfig_args) that); + return false; + } + + public boolean equals(getConfig_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(getConfig_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("getConfig_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, 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 getConfig_argsStandardSchemeFactory implements SchemeFactory { + public getConfig_argsStandardScheme getScheme() { + return new getConfig_argsStandardScheme(); + } + } + + private static class getConfig_argsStandardScheme extends StandardScheme<getConfig_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getConfig_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, getConfig_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getConfig_argsTupleSchemeFactory implements SchemeFactory { + public getConfig_argsTupleScheme getScheme() { + return new getConfig_argsTupleScheme(); + } + } + + private static class getConfig_argsTupleScheme extends TupleScheme<getConfig_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getConfig_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getConfig_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class getConfig_result implements org.apache.thrift.TBase<getConfig_result, getConfig_result._Fields>, java.io.Serializable, Cloneable, Comparable<getConfig_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfig_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getConfig_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getConfig_resultTupleSchemeFactory()); + } + + public Map<String, ConfigSection> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } + + @Override + public int describeContents() { + return 0; + } + + public getConfig_result(android.os.Parcel in) { + this.success = new HashMap<String, ConfigSection>(); + in.readMap(this.success, getConfig_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<getConfig_result> CREATOR = new android.os.Parcelable.Creator<getConfig_result>() { + @Override + public getConfig_result[] newArray(int size) { + return new getConfig_result[size]; + } + + @Override + public getConfig_result createFromParcel(android.os.Parcel in) { + return new getConfig_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ConfigSection.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfig_result.class, metaDataMap); + } + + public getConfig_result() { + } + + public getConfig_result( + Map<String, ConfigSection> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getConfig_result(getConfig_result other) { + if (other.isSetSuccess()) { + Map<String, ConfigSection> __this__success = new HashMap<String, ConfigSection>(other.success.size()); + for (Map.Entry<String, ConfigSection> other_element : other.success.entrySet()) { + + String other_element_key = other_element.getKey(); + ConfigSection other_element_value = other_element.getValue(); + + String __this__success_copy_key = other_element_key; + + ConfigSection __this__success_copy_value = new ConfigSection(other_element_value); + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } + + public getConfig_result deepCopy() { + return new getConfig_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(String key, ConfigSection val) { + if (this.success == null) { + this.success = new HashMap<String, ConfigSection>(); + } + this.success.put(key, val); + } + + public Map<String, ConfigSection> getSuccess() { + return this.success; + } + + public getConfig_result setSuccess(Map<String, ConfigSection> 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, ConfigSection>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getConfig_result) + return this.equals((getConfig_result) that); + return false; + } + + public boolean equals(getConfig_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(getConfig_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("getConfig_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, 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 getConfig_resultStandardSchemeFactory implements SchemeFactory { + public getConfig_resultStandardScheme getScheme() { + return new getConfig_resultStandardScheme(); + } + } + + private static class getConfig_resultStandardScheme extends StandardScheme<getConfig_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getConfig_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 _map84 = iprot.readMapBegin(); + struct.success = new HashMap<String, ConfigSection>(2 * _map84.size); + String _key85; + ConfigSection _val86; + for (int _i87 = 0; _i87 < _map84.size; ++_i87) { + _key85 = iprot.readString(); + _val86 = new ConfigSection(); + _val86.read(iprot); + struct.success.put(_key85, _val86); + } + iprot.readMapEnd(); + } + 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, getConfig_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 (Map.Entry<String, ConfigSection> _iter88 : struct.success.entrySet()) { + oprot.writeString(_iter88.getKey()); + _iter88.getValue().write(oprot); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getConfig_resultTupleSchemeFactory implements SchemeFactory { + public getConfig_resultTupleScheme getScheme() { + return new getConfig_resultTupleScheme(); + } + } + + private static class getConfig_resultTupleScheme extends TupleScheme<getConfig_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getConfig_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, ConfigSection> _iter89 : struct.success.entrySet()) { + oprot.writeString(_iter89.getKey()); + _iter89.getValue().write(oprot); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getConfig_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map90 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap<String, ConfigSection>(2 * _map90.size); + String _key91; + ConfigSection _val92; + for (int _i93 = 0; _i93 < _map90.size; ++_i93) { + _key91 = iprot.readString(); + _val92 = new ConfigSection(); + _val92.read(iprot); + struct.success.put(_key91, _val92); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class getPluginConfig_args implements org.apache.thrift.TBase<getPluginConfig_args, getPluginConfig_args._Fields>, java.io.Serializable, Cloneable, Comparable<getPluginConfig_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPluginConfig_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getPluginConfig_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPluginConfig_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public getPluginConfig_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<getPluginConfig_args> CREATOR = new android.os.Parcelable.Creator<getPluginConfig_args>() { + @Override + public getPluginConfig_args[] newArray(int size) { + return new getPluginConfig_args[size]; + } + + @Override + public getPluginConfig_args createFromParcel(android.os.Parcel in) { + return new getPluginConfig_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPluginConfig_args.class, metaDataMap); + } + + public getPluginConfig_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getPluginConfig_args(getPluginConfig_args other) { + } + + public getPluginConfig_args deepCopy() { + return new getPluginConfig_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPluginConfig_args) + return this.equals((getPluginConfig_args) that); + return false; + } + + public boolean equals(getPluginConfig_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(getPluginConfig_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("getPluginConfig_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, 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 getPluginConfig_argsStandardSchemeFactory implements SchemeFactory { + public getPluginConfig_argsStandardScheme getScheme() { + return new getPluginConfig_argsStandardScheme(); + } + } + + private static class getPluginConfig_argsStandardScheme extends StandardScheme<getPluginConfig_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getPluginConfig_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, getPluginConfig_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getPluginConfig_argsTupleSchemeFactory implements SchemeFactory { + public getPluginConfig_argsTupleScheme getScheme() { + return new getPluginConfig_argsTupleScheme(); + } + } + + private static class getPluginConfig_argsTupleScheme extends TupleScheme<getPluginConfig_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class getPluginConfig_result implements org.apache.thrift.TBase<getPluginConfig_result, getPluginConfig_result._Fields>, java.io.Serializable, Cloneable, Comparable<getPluginConfig_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPluginConfig_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getPluginConfig_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPluginConfig_resultTupleSchemeFactory()); + } + + public Map<String, ConfigSection> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } + + @Override + public int describeContents() { + return 0; + } + + public getPluginConfig_result(android.os.Parcel in) { + this.success = new HashMap<String, ConfigSection>(); + in.readMap(this.success, getPluginConfig_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<getPluginConfig_result> CREATOR = new android.os.Parcelable.Creator<getPluginConfig_result>() { + @Override + public getPluginConfig_result[] newArray(int size) { + return new getPluginConfig_result[size]; + } + + @Override + public getPluginConfig_result createFromParcel(android.os.Parcel in) { + return new getPluginConfig_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ConfigSection.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPluginConfig_result.class, metaDataMap); + } + + public getPluginConfig_result() { + } + + public getPluginConfig_result( + Map<String, ConfigSection> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getPluginConfig_result(getPluginConfig_result other) { + if (other.isSetSuccess()) { + Map<String, ConfigSection> __this__success = new HashMap<String, ConfigSection>(other.success.size()); + for (Map.Entry<String, ConfigSection> other_element : other.success.entrySet()) { + + String other_element_key = other_element.getKey(); + ConfigSection other_element_value = other_element.getValue(); + + String __this__success_copy_key = other_element_key; + + ConfigSection __this__success_copy_value = new ConfigSection(other_element_value); + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } + + public getPluginConfig_result deepCopy() { + return new getPluginConfig_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(String key, ConfigSection val) { + if (this.success == null) { + this.success = new HashMap<String, ConfigSection>(); + } + this.success.put(key, val); + } + + public Map<String, ConfigSection> getSuccess() { + return this.success; + } + + public getPluginConfig_result setSuccess(Map<String, ConfigSection> 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, ConfigSection>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPluginConfig_result) + return this.equals((getPluginConfig_result) that); + return false; + } + + public boolean equals(getPluginConfig_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(getPluginConfig_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("getPluginConfig_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, 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 getPluginConfig_resultStandardSchemeFactory implements SchemeFactory { + public getPluginConfig_resultStandardScheme getScheme() { + return new getPluginConfig_resultStandardScheme(); + } + } + + private static class getPluginConfig_resultStandardScheme extends StandardScheme<getPluginConfig_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getPluginConfig_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 _map94 = iprot.readMapBegin(); + struct.success = new HashMap<String, ConfigSection>(2 * _map94.size); + String _key95; + ConfigSection _val96; + for (int _i97 = 0; _i97 < _map94.size; ++_i97) { + _key95 = iprot.readString(); + _val96 = new ConfigSection(); + _val96.read(iprot); + struct.success.put(_key95, _val96); + } + iprot.readMapEnd(); + } + 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, getPluginConfig_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 (Map.Entry<String, ConfigSection> _iter98 : struct.success.entrySet()) { + oprot.writeString(_iter98.getKey()); + _iter98.getValue().write(oprot); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getPluginConfig_resultTupleSchemeFactory implements SchemeFactory { + public getPluginConfig_resultTupleScheme getScheme() { + return new getPluginConfig_resultTupleScheme(); + } + } + + private static class getPluginConfig_resultTupleScheme extends TupleScheme<getPluginConfig_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, ConfigSection> _iter99 : struct.success.entrySet()) { + oprot.writeString(_iter99.getKey()); + _iter99.getValue().write(oprot); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map100 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap<String, ConfigSection>(2 * _map100.size); + String _key101; + ConfigSection _val102; + for (int _i103 = 0; _i103 < _map100.size; ++_i103) { + _key101 = iprot.readString(); + _val102 = new ConfigSection(); + _val102.read(iprot); + struct.success.put(_key101, _val102); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class pauseServer_args implements org.apache.thrift.TBase<pauseServer_args, pauseServer_args._Fields>, java.io.Serializable, Cloneable, Comparable<pauseServer_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pauseServer_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new pauseServer_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pauseServer_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public pauseServer_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<pauseServer_args> CREATOR = new android.os.Parcelable.Creator<pauseServer_args>() { + @Override + public pauseServer_args[] newArray(int size) { + return new pauseServer_args[size]; + } + + @Override + public pauseServer_args createFromParcel(android.os.Parcel in) { + return new pauseServer_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pauseServer_args.class, metaDataMap); + } + + public pauseServer_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public pauseServer_args(pauseServer_args other) { + } + + public pauseServer_args deepCopy() { + return new pauseServer_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pauseServer_args) + return this.equals((pauseServer_args) that); + return false; + } + + public boolean equals(pauseServer_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(pauseServer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("pauseServer_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, 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 pauseServer_argsStandardSchemeFactory implements SchemeFactory { + public pauseServer_argsStandardScheme getScheme() { + return new pauseServer_argsStandardScheme(); + } + } + + private static class pauseServer_argsStandardScheme extends StandardScheme<pauseServer_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, pauseServer_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, pauseServer_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class pauseServer_argsTupleSchemeFactory implements SchemeFactory { + public pauseServer_argsTupleScheme getScheme() { + return new pauseServer_argsTupleScheme(); + } + } + + private static class pauseServer_argsTupleScheme extends TupleScheme<pauseServer_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pauseServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pauseServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class pauseServer_result implements org.apache.thrift.TBase<pauseServer_result, pauseServer_result._Fields>, java.io.Serializable, Cloneable, Comparable<pauseServer_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pauseServer_result"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new pauseServer_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pauseServer_resultTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public pauseServer_result(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<pauseServer_result> CREATOR = new android.os.Parcelable.Creator<pauseServer_result>() { + @Override + public pauseServer_result[] newArray(int size) { + return new pauseServer_result[size]; + } + + @Override + public pauseServer_result createFromParcel(android.os.Parcel in) { + return new pauseServer_result(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pauseServer_result.class, metaDataMap); + } + + public pauseServer_result() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public pauseServer_result(pauseServer_result other) { + } + + public pauseServer_result deepCopy() { + return new pauseServer_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pauseServer_result) + return this.equals((pauseServer_result) that); + return false; + } + + public boolean equals(pauseServer_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(pauseServer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("pauseServer_result("); + 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, 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 pauseServer_resultStandardSchemeFactory implements SchemeFactory { + public pauseServer_resultStandardScheme getScheme() { + return new pauseServer_resultStandardScheme(); + } + } + + private static class pauseServer_resultStandardScheme extends StandardScheme<pauseServer_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, pauseServer_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) { + 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, pauseServer_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class pauseServer_resultTupleSchemeFactory implements SchemeFactory { + public pauseServer_resultTupleScheme getScheme() { + return new pauseServer_resultTupleScheme(); + } + } + + private static class pauseServer_resultTupleScheme extends TupleScheme<pauseServer_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pauseServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pauseServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class unpauseServer_args implements org.apache.thrift.TBase<unpauseServer_args, unpauseServer_args._Fields>, java.io.Serializable, Cloneable, Comparable<unpauseServer_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("unpauseServer_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new unpauseServer_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new unpauseServer_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public unpauseServer_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<unpauseServer_args> CREATOR = new android.os.Parcelable.Creator<unpauseServer_args>() { + @Override + public unpauseServer_args[] newArray(int size) { + return new unpauseServer_args[size]; + } + + @Override + public unpauseServer_args createFromParcel(android.os.Parcel in) { + return new unpauseServer_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(unpauseServer_args.class, metaDataMap); + } + + public unpauseServer_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public unpauseServer_args(unpauseServer_args other) { + } + + public unpauseServer_args deepCopy() { + return new unpauseServer_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof unpauseServer_args) + return this.equals((unpauseServer_args) that); + return false; + } + + public boolean equals(unpauseServer_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(unpauseServer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("unpauseServer_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, 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 unpauseServer_argsStandardSchemeFactory implements SchemeFactory { + public unpauseServer_argsStandardScheme getScheme() { + return new unpauseServer_argsStandardScheme(); + } + } + + private static class unpauseServer_argsStandardScheme extends StandardScheme<unpauseServer_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, unpauseServer_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, unpauseServer_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class unpauseServer_argsTupleSchemeFactory implements SchemeFactory { + public unpauseServer_argsTupleScheme getScheme() { + return new unpauseServer_argsTupleScheme(); + } + } + + private static class unpauseServer_argsTupleScheme extends TupleScheme<unpauseServer_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, unpauseServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, unpauseServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class unpauseServer_result implements org.apache.thrift.TBase<unpauseServer_result, unpauseServer_result._Fields>, java.io.Serializable, Cloneable, Comparable<unpauseServer_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("unpauseServer_result"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new unpauseServer_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new unpauseServer_resultTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public unpauseServer_result(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<unpauseServer_result> CREATOR = new android.os.Parcelable.Creator<unpauseServer_result>() { + @Override + public unpauseServer_result[] newArray(int size) { + return new unpauseServer_result[size]; + } + + @Override + public unpauseServer_result createFromParcel(android.os.Parcel in) { + return new unpauseServer_result(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(unpauseServer_result.class, metaDataMap); + } + + public unpauseServer_result() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public unpauseServer_result(unpauseServer_result other) { + } + + public unpauseServer_result deepCopy() { + return new unpauseServer_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof unpauseServer_result) + return this.equals((unpauseServer_result) that); + return false; + } + + public boolean equals(unpauseServer_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(unpauseServer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("unpauseServer_result("); + 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, 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 unpauseServer_resultStandardSchemeFactory implements SchemeFactory { + public unpauseServer_resultStandardScheme getScheme() { + return new unpauseServer_resultStandardScheme(); + } + } + + private static class unpauseServer_resultStandardScheme extends StandardScheme<unpauseServer_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, unpauseServer_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) { + 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, unpauseServer_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class unpauseServer_resultTupleSchemeFactory implements SchemeFactory { + public unpauseServer_resultTupleScheme getScheme() { + return new unpauseServer_resultTupleScheme(); + } + } + + private static class unpauseServer_resultTupleScheme extends TupleScheme<unpauseServer_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, unpauseServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, unpauseServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class togglePause_args implements org.apache.thrift.TBase<togglePause_args, togglePause_args._Fields>, java.io.Serializable, Cloneable, Comparable<togglePause_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("togglePause_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new togglePause_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new togglePause_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public togglePause_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<togglePause_args> CREATOR = new android.os.Parcelable.Creator<togglePause_args>() { + @Override + public togglePause_args[] newArray(int size) { + return new togglePause_args[size]; + } + + @Override + public togglePause_args createFromParcel(android.os.Parcel in) { + return new togglePause_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(togglePause_args.class, metaDataMap); + } + + public togglePause_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public togglePause_args(togglePause_args other) { + } + + public togglePause_args deepCopy() { + return new togglePause_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof togglePause_args) + return this.equals((togglePause_args) that); + return false; + } + + public boolean equals(togglePause_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(togglePause_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("togglePause_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, 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 togglePause_argsStandardSchemeFactory implements SchemeFactory { + public togglePause_argsStandardScheme getScheme() { + return new togglePause_argsStandardScheme(); + } + } + + private static class togglePause_argsStandardScheme extends StandardScheme<togglePause_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, togglePause_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, togglePause_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class togglePause_argsTupleSchemeFactory implements SchemeFactory { + public togglePause_argsTupleScheme getScheme() { + return new togglePause_argsTupleScheme(); + } + } + + private static class togglePause_argsTupleScheme extends TupleScheme<togglePause_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, togglePause_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, togglePause_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class togglePause_result implements org.apache.thrift.TBase<togglePause_result, togglePause_result._Fields>, java.io.Serializable, Cloneable, Comparable<togglePause_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("togglePause_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new togglePause_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new togglePause_resultTupleSchemeFactory()); + } + + public boolean success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(success ? 1 : 0); + } + + @Override + public int describeContents() { + return 0; + } + + public togglePause_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.success = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<togglePause_result> CREATOR = new android.os.Parcelable.Creator<togglePause_result>() { + @Override + public togglePause_result[] newArray(int size) { + return new togglePause_result[size]; + } + + @Override + public togglePause_result createFromParcel(android.os.Parcel in) { + return new togglePause_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(togglePause_result.class, metaDataMap); + } + + public togglePause_result() { + } + + public togglePause_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public togglePause_result(togglePause_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } + + public togglePause_result deepCopy() { + return new togglePause_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } + + public boolean isSuccess() { + return this.success; + } + + public togglePause_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof togglePause_result) + return this.equals((togglePause_result) that); + return false; + } + + public boolean equals(togglePause_result that) { + if (that == null) + return false; + + 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; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(togglePause_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("togglePause_result("); + boolean first = true; + + sb.append("success:"); + 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, 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 togglePause_resultStandardSchemeFactory implements SchemeFactory { + public togglePause_resultStandardScheme getScheme() { + return new togglePause_resultStandardScheme(); + } + } + + private static class togglePause_resultStandardScheme extends StandardScheme<togglePause_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, togglePause_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; + 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, togglePause_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class togglePause_resultTupleSchemeFactory implements SchemeFactory { + public togglePause_resultTupleScheme getScheme() { + return new togglePause_resultTupleScheme(); + } + } + + private static class togglePause_resultTupleScheme extends TupleScheme<togglePause_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, togglePause_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, togglePause_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class statusServer_args implements org.apache.thrift.TBase<statusServer_args, statusServer_args._Fields>, java.io.Serializable, Cloneable, Comparable<statusServer_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusServer_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new statusServer_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new statusServer_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public statusServer_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<statusServer_args> CREATOR = new android.os.Parcelable.Creator<statusServer_args>() { + @Override + public statusServer_args[] newArray(int size) { + return new statusServer_args[size]; + } + + @Override + public statusServer_args createFromParcel(android.os.Parcel in) { + return new statusServer_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusServer_args.class, metaDataMap); + } + + public statusServer_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public statusServer_args(statusServer_args other) { + } + + public statusServer_args deepCopy() { + return new statusServer_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof statusServer_args) + return this.equals((statusServer_args) that); + return false; + } + + public boolean equals(statusServer_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(statusServer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("statusServer_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, 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 statusServer_argsStandardSchemeFactory implements SchemeFactory { + public statusServer_argsStandardScheme getScheme() { + return new statusServer_argsStandardScheme(); + } + } + + private static class statusServer_argsStandardScheme extends StandardScheme<statusServer_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, statusServer_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, statusServer_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class statusServer_argsTupleSchemeFactory implements SchemeFactory { + public statusServer_argsTupleScheme getScheme() { + return new statusServer_argsTupleScheme(); + } + } + + private static class statusServer_argsTupleScheme extends TupleScheme<statusServer_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, statusServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, statusServer_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class statusServer_result implements org.apache.thrift.TBase<statusServer_result, statusServer_result._Fields>, java.io.Serializable, Cloneable, Comparable<statusServer_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusServer_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new statusServer_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new statusServer_resultTupleSchemeFactory()); + } + + public ServerStatus success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } + + @Override + public int describeContents() { + return 0; + } + + public statusServer_result(android.os.Parcel in) { + this.success = in.readParcelable(statusServer_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<statusServer_result> CREATOR = new android.os.Parcelable.Creator<statusServer_result>() { + @Override + public statusServer_result[] newArray(int size) { + return new statusServer_result[size]; + } + + @Override + public statusServer_result createFromParcel(android.os.Parcel in) { + return new statusServer_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ServerStatus.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusServer_result.class, metaDataMap); + } + + public statusServer_result() { + } + + public statusServer_result( + ServerStatus success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public statusServer_result(statusServer_result other) { + if (other.isSetSuccess()) { + this.success = new ServerStatus(other.success); + } + } + + public statusServer_result deepCopy() { + return new statusServer_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public ServerStatus getSuccess() { + return this.success; + } + + public statusServer_result setSuccess(ServerStatus 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((ServerStatus) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof statusServer_result) + return this.equals((statusServer_result) that); + return false; + } + + public boolean equals(statusServer_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(statusServer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("statusServer_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 + 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, 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 statusServer_resultStandardSchemeFactory implements SchemeFactory { + public statusServer_resultStandardScheme getScheme() { + return new statusServer_resultStandardScheme(); + } + } + + private static class statusServer_resultStandardScheme extends StandardScheme<statusServer_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, statusServer_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 ServerStatus(); + struct.success.read(iprot); + 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, statusServer_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class statusServer_resultTupleSchemeFactory implements SchemeFactory { + public statusServer_resultTupleScheme getScheme() { + return new statusServer_resultTupleScheme(); + } + } + + private static class statusServer_resultTupleScheme extends TupleScheme<statusServer_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, statusServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, statusServer_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new ServerStatus(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class freeSpace_args implements org.apache.thrift.TBase<freeSpace_args, freeSpace_args._Fields>, java.io.Serializable, Cloneable, Comparable<freeSpace_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("freeSpace_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new freeSpace_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new freeSpace_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public freeSpace_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<freeSpace_args> CREATOR = new android.os.Parcelable.Creator<freeSpace_args>() { + @Override + public freeSpace_args[] newArray(int size) { + return new freeSpace_args[size]; + } + + @Override + public freeSpace_args createFromParcel(android.os.Parcel in) { + return new freeSpace_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(freeSpace_args.class, metaDataMap); + } + + public freeSpace_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public freeSpace_args(freeSpace_args other) { + } + + public freeSpace_args deepCopy() { + return new freeSpace_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof freeSpace_args) + return this.equals((freeSpace_args) that); + return false; + } + + public boolean equals(freeSpace_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(freeSpace_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("freeSpace_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, 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 freeSpace_argsStandardSchemeFactory implements SchemeFactory { + public freeSpace_argsStandardScheme getScheme() { + return new freeSpace_argsStandardScheme(); + } + } + + private static class freeSpace_argsStandardScheme extends StandardScheme<freeSpace_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, freeSpace_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, freeSpace_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class freeSpace_argsTupleSchemeFactory implements SchemeFactory { + public freeSpace_argsTupleScheme getScheme() { + return new freeSpace_argsTupleScheme(); + } + } + + private static class freeSpace_argsTupleScheme extends TupleScheme<freeSpace_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, freeSpace_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, freeSpace_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class freeSpace_result implements org.apache.thrift.TBase<freeSpace_result, freeSpace_result._Fields>, java.io.Serializable, Cloneable, Comparable<freeSpace_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("freeSpace_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new freeSpace_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new freeSpace_resultTupleSchemeFactory()); + } + + public long success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeLong(success); + } + + @Override + public int describeContents() { + return 0; + } + + public freeSpace_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.success = in.readLong(); + } + + public static final android.os.Parcelable.Creator<freeSpace_result> CREATOR = new android.os.Parcelable.Creator<freeSpace_result>() { + @Override + public freeSpace_result[] newArray(int size) { + return new freeSpace_result[size]; + } + + @Override + public freeSpace_result createFromParcel(android.os.Parcel in) { + return new freeSpace_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(freeSpace_result.class, metaDataMap); + } + + public freeSpace_result() { + } + + public freeSpace_result( + long success) { + this(); + this.success = success; + setSuccessIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public freeSpace_result(freeSpace_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } + + public freeSpace_result deepCopy() { + return new freeSpace_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = 0; + } + + public long getSuccess() { + return this.success; + } + + public freeSpace_result setSuccess(long success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Long) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof freeSpace_result) + return this.equals((freeSpace_result) that); + return false; + } + + public boolean equals(freeSpace_result that) { + if (that == null) + return false; + + 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; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(freeSpace_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("freeSpace_result("); + boolean first = true; + + sb.append("success:"); + 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, 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 freeSpace_resultStandardSchemeFactory implements SchemeFactory { + public freeSpace_resultStandardScheme getScheme() { + return new freeSpace_resultStandardScheme(); + } + } + + private static class freeSpace_resultStandardScheme extends StandardScheme<freeSpace_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, freeSpace_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; + 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, freeSpace_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class freeSpace_resultTupleSchemeFactory implements SchemeFactory { + public freeSpace_resultTupleScheme getScheme() { + return new freeSpace_resultTupleScheme(); + } + } + + private static class freeSpace_resultTupleScheme extends TupleScheme<freeSpace_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, freeSpace_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeI64(struct.success); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, freeSpace_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readI64(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class getServerVersion_args implements org.apache.thrift.TBase<getServerVersion_args, getServerVersion_args._Fields>, java.io.Serializable, Cloneable, Comparable<getServerVersion_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServerVersion_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getServerVersion_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getServerVersion_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public getServerVersion_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<getServerVersion_args> CREATOR = new android.os.Parcelable.Creator<getServerVersion_args>() { + @Override + public getServerVersion_args[] newArray(int size) { + return new getServerVersion_args[size]; + } + + @Override + public getServerVersion_args createFromParcel(android.os.Parcel in) { + return new getServerVersion_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServerVersion_args.class, metaDataMap); + } + + public getServerVersion_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getServerVersion_args(getServerVersion_args other) { + } + + public getServerVersion_args deepCopy() { + return new getServerVersion_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getServerVersion_args) + return this.equals((getServerVersion_args) that); + return false; + } + + public boolean equals(getServerVersion_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(getServerVersion_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("getServerVersion_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, 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 getServerVersion_argsStandardSchemeFactory implements SchemeFactory { + public getServerVersion_argsStandardScheme getScheme() { + return new getServerVersion_argsStandardScheme(); + } + } + + private static class getServerVersion_argsStandardScheme extends StandardScheme<getServerVersion_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getServerVersion_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, getServerVersion_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getServerVersion_argsTupleSchemeFactory implements SchemeFactory { + public getServerVersion_argsTupleScheme getScheme() { + return new getServerVersion_argsTupleScheme(); + } + } + + private static class getServerVersion_argsTupleScheme extends TupleScheme<getServerVersion_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getServerVersion_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getServerVersion_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class getServerVersion_result implements org.apache.thrift.TBase<getServerVersion_result, getServerVersion_result._Fields>, java.io.Serializable, Cloneable, Comparable<getServerVersion_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServerVersion_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getServerVersion_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getServerVersion_resultTupleSchemeFactory()); + } + + public String success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(success); + } + + @Override + public int describeContents() { + return 0; + } + + public getServerVersion_result(android.os.Parcel in) { + this.success = in.readString(); + } + + public static final android.os.Parcelable.Creator<getServerVersion_result> CREATOR = new android.os.Parcelable.Creator<getServerVersion_result>() { + @Override + public getServerVersion_result[] newArray(int size) { + return new getServerVersion_result[size]; + } + + @Override + public getServerVersion_result createFromParcel(android.os.Parcel in) { + return new getServerVersion_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServerVersion_result.class, metaDataMap); + } + + public getServerVersion_result() { + } + + public getServerVersion_result( + String success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getServerVersion_result(getServerVersion_result other) { + if (other.isSetSuccess()) { + this.success = other.success; + } + } + + public getServerVersion_result deepCopy() { + return new getServerVersion_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public String getSuccess() { + return this.success; + } + + public getServerVersion_result setSuccess(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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getServerVersion_result) + return this.equals((getServerVersion_result) that); + return false; + } + + public boolean equals(getServerVersion_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(getServerVersion_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("getServerVersion_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, 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 getServerVersion_resultStandardSchemeFactory implements SchemeFactory { + public getServerVersion_resultStandardScheme getScheme() { + return new getServerVersion_resultStandardScheme(); + } + } + + private static class getServerVersion_resultStandardScheme extends StandardScheme<getServerVersion_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getServerVersion_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, getServerVersion_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 getServerVersion_resultTupleSchemeFactory implements SchemeFactory { + public getServerVersion_resultTupleScheme getScheme() { + return new getServerVersion_resultTupleScheme(); + } + } + + private static class getServerVersion_resultTupleScheme extends TupleScheme<getServerVersion_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getServerVersion_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new 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, getServerVersion_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readString(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class kill_args implements org.apache.thrift.TBase<kill_args, kill_args._Fields>, java.io.Serializable, Cloneable, Comparable<kill_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("kill_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new kill_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new kill_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public kill_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<kill_args> CREATOR = new android.os.Parcelable.Creator<kill_args>() { + @Override + public kill_args[] newArray(int size) { + return new kill_args[size]; + } + + @Override + public kill_args createFromParcel(android.os.Parcel in) { + return new kill_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(kill_args.class, metaDataMap); + } + + public kill_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public kill_args(kill_args other) { + } + + public kill_args deepCopy() { + return new kill_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof kill_args) + return this.equals((kill_args) that); + return false; + } + + public boolean equals(kill_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(kill_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("kill_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, 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 kill_argsStandardSchemeFactory implements SchemeFactory { + public kill_argsStandardScheme getScheme() { + return new kill_argsStandardScheme(); + } + } + + private static class kill_argsStandardScheme extends StandardScheme<kill_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, kill_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, kill_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class kill_argsTupleSchemeFactory implements SchemeFactory { + public kill_argsTupleScheme getScheme() { + return new kill_argsTupleScheme(); + } + } + + private static class kill_argsTupleScheme extends TupleScheme<kill_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, kill_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, kill_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class kill_result implements org.apache.thrift.TBase<kill_result, kill_result._Fields>, java.io.Serializable, Cloneable, Comparable<kill_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("kill_result"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new kill_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new kill_resultTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public kill_result(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<kill_result> CREATOR = new android.os.Parcelable.Creator<kill_result>() { + @Override + public kill_result[] newArray(int size) { + return new kill_result[size]; + } + + @Override + public kill_result createFromParcel(android.os.Parcel in) { + return new kill_result(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(kill_result.class, metaDataMap); + } + + public kill_result() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public kill_result(kill_result other) { + } + + public kill_result deepCopy() { + return new kill_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof kill_result) + return this.equals((kill_result) that); + return false; + } + + public boolean equals(kill_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(kill_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("kill_result("); + 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, 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 kill_resultStandardSchemeFactory implements SchemeFactory { + public kill_resultStandardScheme getScheme() { + return new kill_resultStandardScheme(); + } + } + + private static class kill_resultStandardScheme extends StandardScheme<kill_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, kill_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) { + 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, kill_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class kill_resultTupleSchemeFactory implements SchemeFactory { + public kill_resultTupleScheme getScheme() { + return new kill_resultTupleScheme(); + } + } + + private static class kill_resultTupleScheme extends TupleScheme<kill_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, kill_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, kill_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class restart_args implements org.apache.thrift.TBase<restart_args, restart_args._Fields>, java.io.Serializable, Cloneable, Comparable<restart_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restart_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new restart_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restart_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public restart_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<restart_args> CREATOR = new android.os.Parcelable.Creator<restart_args>() { + @Override + public restart_args[] newArray(int size) { + return new restart_args[size]; + } + + @Override + public restart_args createFromParcel(android.os.Parcel in) { + return new restart_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restart_args.class, metaDataMap); + } + + public restart_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public restart_args(restart_args other) { + } + + public restart_args deepCopy() { + return new restart_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restart_args) + return this.equals((restart_args) that); + return false; + } + + public boolean equals(restart_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(restart_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("restart_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, 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 restart_argsStandardSchemeFactory implements SchemeFactory { + public restart_argsStandardScheme getScheme() { + return new restart_argsStandardScheme(); + } + } + + private static class restart_argsStandardScheme extends StandardScheme<restart_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, restart_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, restart_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class restart_argsTupleSchemeFactory implements SchemeFactory { + public restart_argsTupleScheme getScheme() { + return new restart_argsTupleScheme(); + } + } + + private static class restart_argsTupleScheme extends TupleScheme<restart_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restart_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restart_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class restart_result implements org.apache.thrift.TBase<restart_result, restart_result._Fields>, java.io.Serializable, Cloneable, Comparable<restart_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restart_result"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new restart_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restart_resultTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public restart_result(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<restart_result> CREATOR = new android.os.Parcelable.Creator<restart_result>() { + @Override + public restart_result[] newArray(int size) { + return new restart_result[size]; + } + + @Override + public restart_result createFromParcel(android.os.Parcel in) { + return new restart_result(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restart_result.class, metaDataMap); + } + + public restart_result() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public restart_result(restart_result other) { + } + + public restart_result deepCopy() { + return new restart_result(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restart_result) + return this.equals((restart_result) that); + return false; + } + + public boolean equals(restart_result that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(restart_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("restart_result("); + 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, 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 restart_resultStandardSchemeFactory implements SchemeFactory { + public restart_resultStandardScheme getScheme() { + return new restart_resultStandardScheme(); + } + } + + private static class restart_resultStandardScheme extends StandardScheme<restart_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, restart_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) { + 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, restart_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class restart_resultTupleSchemeFactory implements SchemeFactory { + public restart_resultTupleScheme getScheme() { + return new restart_resultTupleScheme(); + } + } + + private static class restart_resultTupleScheme extends TupleScheme<restart_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restart_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restart_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class getLog_args implements org.apache.thrift.TBase<getLog_args, getLog_args._Fields>, java.io.Serializable, Cloneable, Comparable<getLog_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLog_args"); + + private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I32, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getLog_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getLog_argsTupleSchemeFactory()); + } + + public int offset; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(offset); + } + + @Override + public int describeContents() { + return 0; + } + + public getLog_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.offset = in.readInt(); + } + + public static final android.os.Parcelable.Creator<getLog_args> CREATOR = new android.os.Parcelable.Creator<getLog_args>() { + @Override + public getLog_args[] newArray(int size) { + return new getLog_args[size]; + } + + @Override + public getLog_args createFromParcel(android.os.Parcel in) { + return new getLog_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + OFFSET((short) 1, "offset"); + + 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: // OFFSET + return OFFSET; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __OFFSET_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLog_args.class, metaDataMap); + } + + public getLog_args() { + } + + public getLog_args( + int offset) { + this(); + this.offset = offset; + setOffsetIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getLog_args(getLog_args other) { + __isset_bitfield = other.__isset_bitfield; + this.offset = other.offset; + } + + public getLog_args deepCopy() { + return new getLog_args(this); + } + + @Override + public void clear() { + setOffsetIsSet(false); + this.offset = 0; + } + + public int getOffset() { + return this.offset; + } + + public getLog_args setOffset(int offset) { + this.offset = offset; + setOffsetIsSet(true); + return this; + } + + public void unsetOffset() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __OFFSET_ISSET_ID); + } + + /** Returns true if field offset is set (has been assigned a value) and false otherwise */ + public boolean isSetOffset() { + return EncodingUtils.testBit(__isset_bitfield, __OFFSET_ISSET_ID); + } + + public void setOffsetIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __OFFSET_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case OFFSET: + if (value == null) { + unsetOffset(); + } else { + setOffset((Integer) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case OFFSET: + return getOffset(); + + } + 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 OFFSET: + return isSetOffset(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getLog_args) + return this.equals((getLog_args) that); + return false; + } + + public boolean equals(getLog_args that) { + if (that == null) + return false; + + boolean this_present_offset = true; + boolean that_present_offset = true; + if (this_present_offset || that_present_offset) { + if (!(this_present_offset && that_present_offset)) + return false; + if (this.offset != that.offset) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_offset = true; + list.add(present_offset); + if (present_offset) + list.add(offset); + + return list.hashCode(); + } + + @Override + public int compareTo(getLog_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetOffset()).compareTo(other.isSetOffset()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOffset()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, other.offset); + 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("getLog_args("); + boolean first = true; + + sb.append("offset:"); + sb.append(this.offset); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 getLog_argsStandardSchemeFactory implements SchemeFactory { + public getLog_argsStandardScheme getScheme() { + return new getLog_argsStandardScheme(); + } + } + + private static class getLog_argsStandardScheme extends StandardScheme<getLog_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getLog_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: // OFFSET + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.offset = iprot.readI32(); + struct.setOffsetIsSet(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, getLog_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(OFFSET_FIELD_DESC); + oprot.writeI32(struct.offset); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getLog_argsTupleSchemeFactory implements SchemeFactory { + public getLog_argsTupleScheme getScheme() { + return new getLog_argsTupleScheme(); + } + } + + private static class getLog_argsTupleScheme extends TupleScheme<getLog_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getLog_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetOffset()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetOffset()) { + oprot.writeI32(struct.offset); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getLog_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.offset = iprot.readI32(); + struct.setOffsetIsSet(true); + } + } + } + + } + + public static class getLog_result implements org.apache.thrift.TBase<getLog_result, getLog_result._Fields>, java.io.Serializable, Cloneable, Comparable<getLog_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLog_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getLog_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getLog_resultTupleSchemeFactory()); + } + + public List<String> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(success); + } + + @Override + public int describeContents() { + return 0; + } + + public getLog_result(android.os.Parcel in) { + this.success = new ArrayList<String>(); + in.readList(this.success, getLog_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<getLog_result> CREATOR = new android.os.Parcelable.Creator<getLog_result>() { + @Override + public getLog_result[] newArray(int size) { + return new getLog_result[size]; + } + + @Override + public getLog_result createFromParcel(android.os.Parcel in) { + return new getLog_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLog_result.class, metaDataMap); + } + + public getLog_result() { + } + + public getLog_result( + List<String> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getLog_result(getLog_result other) { + if (other.isSetSuccess()) { + List<String> __this__success = new ArrayList<String>(other.success); + this.success = __this__success; + } + } + + public getLog_result deepCopy() { + return new getLog_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator<String> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(String elem) { + if (this.success == null) { + this.success = new ArrayList<String>(); + } + this.success.add(elem); + } + + public List<String> getSuccess() { + return this.success; + } + + public getLog_result setSuccess(List<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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<String>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getLog_result) + return this.equals((getLog_result) that); + return false; + } + + public boolean equals(getLog_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(getLog_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("getLog_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, 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 getLog_resultStandardSchemeFactory implements SchemeFactory { + public getLog_resultStandardScheme getScheme() { + return new getLog_resultStandardScheme(); + } + } + + private static class getLog_resultStandardScheme extends StandardScheme<getLog_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getLog_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 ArrayList<String>(_list104.size); + String _elem105; + for (int _i106 = 0; _i106 < _list104.size; ++_i106) { + _elem105 = iprot.readString(); + struct.success.add(_elem105); + } + iprot.readListEnd(); + } + 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, getLog_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 (String _iter107 : struct.success) { + oprot.writeString(_iter107); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getLog_resultTupleSchemeFactory implements SchemeFactory { + public getLog_resultTupleScheme getScheme() { + return new getLog_resultTupleScheme(); + } + } + + private static class getLog_resultTupleScheme extends TupleScheme<getLog_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getLog_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (String _iter108 : struct.success) { + oprot.writeString(_iter108); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getLog_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list109 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList<String>(_list109.size); + String _elem110; + for (int _i111 = 0; _i111 < _list109.size; ++_i111) { + _elem110 = iprot.readString(); + struct.success.add(_elem110); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class isTimeDownload_args implements org.apache.thrift.TBase<isTimeDownload_args, isTimeDownload_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTimeDownload_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeDownload_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new isTimeDownload_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isTimeDownload_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public isTimeDownload_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<isTimeDownload_args> CREATOR = new android.os.Parcelable.Creator<isTimeDownload_args>() { + @Override + public isTimeDownload_args[] newArray(int size) { + return new isTimeDownload_args[size]; + } + + @Override + public isTimeDownload_args createFromParcel(android.os.Parcel in) { + return new isTimeDownload_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeDownload_args.class, metaDataMap); + } + + public isTimeDownload_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public isTimeDownload_args(isTimeDownload_args other) { + } + + public isTimeDownload_args deepCopy() { + return new isTimeDownload_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isTimeDownload_args) + return this.equals((isTimeDownload_args) that); + return false; + } + + public boolean equals(isTimeDownload_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(isTimeDownload_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("isTimeDownload_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, 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 isTimeDownload_argsStandardSchemeFactory implements SchemeFactory { + public isTimeDownload_argsStandardScheme getScheme() { + return new isTimeDownload_argsStandardScheme(); + } + } + + private static class isTimeDownload_argsStandardScheme extends StandardScheme<isTimeDownload_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeDownload_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, isTimeDownload_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class isTimeDownload_argsTupleSchemeFactory implements SchemeFactory { + public isTimeDownload_argsTupleScheme getScheme() { + return new isTimeDownload_argsTupleScheme(); + } + } + + private static class isTimeDownload_argsTupleScheme extends TupleScheme<isTimeDownload_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class isTimeDownload_result implements org.apache.thrift.TBase<isTimeDownload_result, isTimeDownload_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTimeDownload_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeDownload_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new isTimeDownload_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isTimeDownload_resultTupleSchemeFactory()); + } + + public boolean success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(success ? 1 : 0); + } + + @Override + public int describeContents() { + return 0; + } + + public isTimeDownload_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.success = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<isTimeDownload_result> CREATOR = new android.os.Parcelable.Creator<isTimeDownload_result>() { + @Override + public isTimeDownload_result[] newArray(int size) { + return new isTimeDownload_result[size]; + } + + @Override + public isTimeDownload_result createFromParcel(android.os.Parcel in) { + return new isTimeDownload_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeDownload_result.class, metaDataMap); + } + + public isTimeDownload_result() { + } + + public isTimeDownload_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public isTimeDownload_result(isTimeDownload_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } + + public isTimeDownload_result deepCopy() { + return new isTimeDownload_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } + + public boolean isSuccess() { + return this.success; + } + + public isTimeDownload_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isTimeDownload_result) + return this.equals((isTimeDownload_result) that); + return false; + } + + public boolean equals(isTimeDownload_result that) { + if (that == null) + return false; + + 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; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(isTimeDownload_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("isTimeDownload_result("); + boolean first = true; + + sb.append("success:"); + 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, 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 isTimeDownload_resultStandardSchemeFactory implements SchemeFactory { + public isTimeDownload_resultStandardScheme getScheme() { + return new isTimeDownload_resultStandardScheme(); + } + } + + private static class isTimeDownload_resultStandardScheme extends StandardScheme<isTimeDownload_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeDownload_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; + 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, isTimeDownload_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class isTimeDownload_resultTupleSchemeFactory implements SchemeFactory { + public isTimeDownload_resultTupleScheme getScheme() { + return new isTimeDownload_resultTupleScheme(); + } + } + + private static class isTimeDownload_resultTupleScheme extends TupleScheme<isTimeDownload_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class isTimeReconnect_args implements org.apache.thrift.TBase<isTimeReconnect_args, isTimeReconnect_args._Fields>, java.io.Serializable, Cloneable, Comparable<isTimeReconnect_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeReconnect_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new isTimeReconnect_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isTimeReconnect_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public isTimeReconnect_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<isTimeReconnect_args> CREATOR = new android.os.Parcelable.Creator<isTimeReconnect_args>() { + @Override + public isTimeReconnect_args[] newArray(int size) { + return new isTimeReconnect_args[size]; + } + + @Override + public isTimeReconnect_args createFromParcel(android.os.Parcel in) { + return new isTimeReconnect_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeReconnect_args.class, metaDataMap); + } + + public isTimeReconnect_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public isTimeReconnect_args(isTimeReconnect_args other) { + } + + public isTimeReconnect_args deepCopy() { + return new isTimeReconnect_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isTimeReconnect_args) + return this.equals((isTimeReconnect_args) that); + return false; + } + + public boolean equals(isTimeReconnect_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(isTimeReconnect_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("isTimeReconnect_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, 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 isTimeReconnect_argsStandardSchemeFactory implements SchemeFactory { + public isTimeReconnect_argsStandardScheme getScheme() { + return new isTimeReconnect_argsStandardScheme(); + } + } + + private static class isTimeReconnect_argsStandardScheme extends StandardScheme<isTimeReconnect_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeReconnect_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, isTimeReconnect_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class isTimeReconnect_argsTupleSchemeFactory implements SchemeFactory { + public isTimeReconnect_argsTupleScheme getScheme() { + return new isTimeReconnect_argsTupleScheme(); + } + } + + private static class isTimeReconnect_argsTupleScheme extends TupleScheme<isTimeReconnect_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class isTimeReconnect_result implements org.apache.thrift.TBase<isTimeReconnect_result, isTimeReconnect_result._Fields>, java.io.Serializable, Cloneable, Comparable<isTimeReconnect_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeReconnect_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new isTimeReconnect_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isTimeReconnect_resultTupleSchemeFactory()); + } + + public boolean success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(success ? 1 : 0); + } + + @Override + public int describeContents() { + return 0; + } + + public isTimeReconnect_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.success = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<isTimeReconnect_result> CREATOR = new android.os.Parcelable.Creator<isTimeReconnect_result>() { + @Override + public isTimeReconnect_result[] newArray(int size) { + return new isTimeReconnect_result[size]; + } + + @Override + public isTimeReconnect_result createFromParcel(android.os.Parcel in) { + return new isTimeReconnect_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeReconnect_result.class, metaDataMap); + } + + public isTimeReconnect_result() { + } + + public isTimeReconnect_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public isTimeReconnect_result(isTimeReconnect_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } + + public isTimeReconnect_result deepCopy() { + return new isTimeReconnect_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } + + public boolean isSuccess() { + return this.success; + } + + public isTimeReconnect_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isTimeReconnect_result) + return this.equals((isTimeReconnect_result) that); + return false; + } + + public boolean equals(isTimeReconnect_result that) { + if (that == null) + return false; + + 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; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(isTimeReconnect_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("isTimeReconnect_result("); + boolean first = true; + + sb.append("success:"); + 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, 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 isTimeReconnect_resultStandardSchemeFactory implements SchemeFactory { + public isTimeReconnect_resultStandardScheme getScheme() { + return new isTimeReconnect_resultStandardScheme(); + } + } + + private static class isTimeReconnect_resultStandardScheme extends StandardScheme<isTimeReconnect_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeReconnect_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; + 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, isTimeReconnect_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class isTimeReconnect_resultTupleSchemeFactory implements SchemeFactory { + public isTimeReconnect_resultTupleScheme getScheme() { + return new isTimeReconnect_resultTupleScheme(); + } + } + + private static class isTimeReconnect_resultTupleScheme extends TupleScheme<isTimeReconnect_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class toggleReconnect_args implements org.apache.thrift.TBase<toggleReconnect_args, toggleReconnect_args._Fields>, java.io.Serializable, Cloneable, Comparable<toggleReconnect_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("toggleReconnect_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new toggleReconnect_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new toggleReconnect_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public toggleReconnect_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<toggleReconnect_args> CREATOR = new android.os.Parcelable.Creator<toggleReconnect_args>() { + @Override + public toggleReconnect_args[] newArray(int size) { + return new toggleReconnect_args[size]; + } + + @Override + public toggleReconnect_args createFromParcel(android.os.Parcel in) { + return new toggleReconnect_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(toggleReconnect_args.class, metaDataMap); + } + + public toggleReconnect_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public toggleReconnect_args(toggleReconnect_args other) { + } + + public toggleReconnect_args deepCopy() { + return new toggleReconnect_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof toggleReconnect_args) + return this.equals((toggleReconnect_args) that); + return false; + } + + public boolean equals(toggleReconnect_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(toggleReconnect_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("toggleReconnect_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, 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 toggleReconnect_argsStandardSchemeFactory implements SchemeFactory { + public toggleReconnect_argsStandardScheme getScheme() { + return new toggleReconnect_argsStandardScheme(); + } + } + + private static class toggleReconnect_argsStandardScheme extends StandardScheme<toggleReconnect_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, toggleReconnect_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, toggleReconnect_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class toggleReconnect_argsTupleSchemeFactory implements SchemeFactory { + public toggleReconnect_argsTupleScheme getScheme() { + return new toggleReconnect_argsTupleScheme(); + } + } + + private static class toggleReconnect_argsTupleScheme extends TupleScheme<toggleReconnect_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class toggleReconnect_result implements org.apache.thrift.TBase<toggleReconnect_result, toggleReconnect_result._Fields>, java.io.Serializable, Cloneable, Comparable<toggleReconnect_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("toggleReconnect_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new toggleReconnect_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new toggleReconnect_resultTupleSchemeFactory()); + } + + public boolean success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(success ? 1 : 0); + } + + @Override + public int describeContents() { + return 0; + } + + public toggleReconnect_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.success = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<toggleReconnect_result> CREATOR = new android.os.Parcelable.Creator<toggleReconnect_result>() { + @Override + public toggleReconnect_result[] newArray(int size) { + return new toggleReconnect_result[size]; + } + + @Override + public toggleReconnect_result createFromParcel(android.os.Parcel in) { + return new toggleReconnect_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(toggleReconnect_result.class, metaDataMap); + } + + public toggleReconnect_result() { + } + + public toggleReconnect_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public toggleReconnect_result(toggleReconnect_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } + + public toggleReconnect_result deepCopy() { + return new toggleReconnect_result(this); + } + + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } + + public boolean isSuccess() { + return this.success; + } + + public toggleReconnect_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + + public void unsetSuccess() { + __isset_bitfield = 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 EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } + + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof toggleReconnect_result) + return this.equals((toggleReconnect_result) that); + return false; + } + + public boolean equals(toggleReconnect_result that) { + if (that == null) + return false; + + 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; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(toggleReconnect_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("toggleReconnect_result("); + boolean first = true; + + sb.append("success:"); + 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, 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 toggleReconnect_resultStandardSchemeFactory implements SchemeFactory { + public toggleReconnect_resultStandardScheme getScheme() { + return new toggleReconnect_resultStandardScheme(); + } + } + + private static class toggleReconnect_resultStandardScheme extends StandardScheme<toggleReconnect_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, toggleReconnect_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; + 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, toggleReconnect_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class toggleReconnect_resultTupleSchemeFactory implements SchemeFactory { + public toggleReconnect_resultTupleScheme getScheme() { + return new toggleReconnect_resultTupleScheme(); + } + } + + private static class toggleReconnect_resultTupleScheme extends TupleScheme<toggleReconnect_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class generatePackages_args implements org.apache.thrift.TBase<generatePackages_args, generatePackages_args._Fields>, java.io.Serializable, Cloneable, Comparable<generatePackages_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generatePackages_args"); + + private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new generatePackages_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new generatePackages_argsTupleSchemeFactory()); + } + + public List<String> links; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(links); + } + + @Override + public int describeContents() { + return 0; + } + + public generatePackages_args(android.os.Parcel in) { + this.links = new ArrayList<String>(); + in.readList(this.links, generatePackages_args.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<generatePackages_args> CREATOR = new android.os.Parcelable.Creator<generatePackages_args>() { + @Override + public generatePackages_args[] newArray(int size) { + return new generatePackages_args[size]; + } + + @Override + public generatePackages_args createFromParcel(android.os.Parcel in) { + return new generatePackages_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + LINKS((short) 1, "links"); + + 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: // LINKS + return LINKS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generatePackages_args.class, metaDataMap); + } + + public generatePackages_args() { + } + + public generatePackages_args( + List<String> links) { + this(); + this.links = links; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public generatePackages_args(generatePackages_args other) { + if (other.isSetLinks()) { + this.links = other.links; + } + } + + public generatePackages_args deepCopy() { + return new generatePackages_args(this); + } + + @Override + public void clear() { + this.links = null; + } + + public int getLinksSize() { + return (this.links == null) ? 0 : this.links.size(); + } + + public java.util.Iterator<String> getLinksIterator() { + return (this.links == null) ? null : this.links.iterator(); + } + + public void addToLinks(String elem) { + if (this.links == null) { + this.links = new ArrayList<String>(); + } + this.links.add(elem); + } + + public List<String> getLinks() { + return this.links; + } + + public generatePackages_args setLinks(List<String> links) { + this.links = links; + return this; + } + + public void unsetLinks() { + this.links = null; + } + + /** Returns true if field links is set (has been assigned a value) and false otherwise */ + public boolean isSetLinks() { + return this.links != null; + } + + public void setLinksIsSet(boolean value) { + if (!value) { + this.links = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case LINKS: + if (value == null) { + unsetLinks(); + } else { + setLinks((List<String>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case LINKS: + return getLinks(); + + } + 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 LINKS: + return isSetLinks(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof generatePackages_args) + return this.equals((generatePackages_args) that); + return false; + } + + public boolean equals(generatePackages_args that) { + if (that == null) + return false; + + boolean this_present_links = true && this.isSetLinks(); + boolean that_present_links = true && that.isSetLinks(); + if (this_present_links || that_present_links) { + if (!(this_present_links && that_present_links)) + return false; + if (!this.links.equals(that.links)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_links = true && (isSetLinks()); + list.add(present_links); + if (present_links) + list.add(links); + + return list.hashCode(); + } + + @Override + public int compareTo(generatePackages_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetLinks()).compareTo(other.isSetLinks()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinks()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, other.links); + 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("generatePackages_args("); + boolean first = true; + + sb.append("links:"); + if (this.links == null) { + sb.append("null"); + } else { + sb.append(this.links); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class generatePackages_argsStandardSchemeFactory implements SchemeFactory { + public generatePackages_argsStandardScheme getScheme() { + return new generatePackages_argsStandardScheme(); + } + } + + private static class generatePackages_argsStandardScheme extends StandardScheme<generatePackages_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, generatePackages_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: // LINKS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list112 = iprot.readListBegin(); + struct.links = new ArrayList<String>(_list112.size); + String _elem113; + for (int _i114 = 0; _i114 < _list112.size; ++_i114) { + _elem113 = iprot.readString(); + struct.links.add(_elem113); + } + iprot.readListEnd(); + } + struct.setLinksIsSet(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, generatePackages_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.links != null) { + oprot.writeFieldBegin(LINKS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); + for (String _iter115 : struct.links) { + oprot.writeString(_iter115); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class generatePackages_argsTupleSchemeFactory implements SchemeFactory { + public generatePackages_argsTupleScheme getScheme() { + return new generatePackages_argsTupleScheme(); + } + } + + private static class generatePackages_argsTupleScheme extends TupleScheme<generatePackages_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, generatePackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetLinks()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetLinks()) { + { + oprot.writeI32(struct.links.size()); + for (String _iter116 : struct.links) { + oprot.writeString(_iter116); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, generatePackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list117 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.links = new ArrayList<String>(_list117.size); + String _elem118; + for (int _i119 = 0; _i119 < _list117.size; ++_i119) { + _elem118 = iprot.readString(); + struct.links.add(_elem118); + } + } + struct.setLinksIsSet(true); + } + } + } + + } + + public static class generatePackages_result implements org.apache.thrift.TBase<generatePackages_result, generatePackages_result._Fields>, java.io.Serializable, Cloneable, Comparable<generatePackages_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generatePackages_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new generatePackages_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new generatePackages_resultTupleSchemeFactory()); + } + + public Map<String, List<String>> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } + + @Override + public int describeContents() { + return 0; + } + + public generatePackages_result(android.os.Parcel in) { + this.success = new HashMap<String, List<String>>(); + in.readMap(this.success, generatePackages_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<generatePackages_result> CREATOR = new android.os.Parcelable.Creator<generatePackages_result>() { + @Override + public generatePackages_result[] newArray(int size) { + return new generatePackages_result[size]; + } + + @Override + public generatePackages_result createFromParcel(android.os.Parcel in) { + return new generatePackages_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.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.LIST, "LinkList")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generatePackages_result.class, metaDataMap); + } + + public generatePackages_result() { + } + + public generatePackages_result( + Map<String, List<String>> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public generatePackages_result(generatePackages_result other) { + if (other.isSetSuccess()) { + Map<String, List<String>> __this__success = new HashMap<String, List<String>>(other.success.size()); + for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + + String other_element_key = other_element.getKey(); + List<String> other_element_value = other_element.getValue(); + + String __this__success_copy_key = other_element_key; + + List<String> __this__success_copy_value = other_element_value; + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } + + public generatePackages_result deepCopy() { + return new generatePackages_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(String key, List<String> val) { + if (this.success == null) { + this.success = new HashMap<String, List<String>>(); + } + this.success.put(key, val); + } + + public Map<String, List<String>> getSuccess() { + return this.success; + } + + public generatePackages_result setSuccess(Map<String, List<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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, List<String>>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof generatePackages_result) + return this.equals((generatePackages_result) that); + return false; + } + + public boolean equals(generatePackages_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(generatePackages_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("generatePackages_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, 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 generatePackages_resultStandardSchemeFactory implements SchemeFactory { + public generatePackages_resultStandardScheme getScheme() { + return new generatePackages_resultStandardScheme(); + } + } + + private static class generatePackages_resultStandardScheme extends StandardScheme<generatePackages_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, generatePackages_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 _map120 = iprot.readMapBegin(); + struct.success = new HashMap<String, List<String>>(2 * _map120.size); + String _key121; + List<String> _val122; + for (int _i123 = 0; _i123 < _map120.size; ++_i123) { + _key121 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list124 = iprot.readListBegin(); + _val122 = new ArrayList<String>(_list124.size); + String _elem125; + for (int _i126 = 0; _i126 < _list124.size; ++_i126) { + _elem125 = iprot.readString(); + _val122.add(_elem125); + } + iprot.readListEnd(); + } + struct.success.put(_key121, _val122); + } + iprot.readMapEnd(); + } + 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, generatePackages_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.LIST, struct.success.size())); + for (Map.Entry<String, List<String>> _iter127 : struct.success.entrySet()) { + oprot.writeString(_iter127.getKey()); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter127.getValue().size())); + for (String _iter128 : _iter127.getValue()) { + oprot.writeString(_iter128); + } + oprot.writeListEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class generatePackages_resultTupleSchemeFactory implements SchemeFactory { + public generatePackages_resultTupleScheme getScheme() { + return new generatePackages_resultTupleScheme(); + } + } + + private static class generatePackages_resultTupleScheme extends TupleScheme<generatePackages_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, generatePackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, List<String>> _iter129 : struct.success.entrySet()) { + oprot.writeString(_iter129.getKey()); + { + oprot.writeI32(_iter129.getValue().size()); + for (String _iter130 : _iter129.getValue()) { + oprot.writeString(_iter130); + } + } + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, generatePackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map131 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.success = new HashMap<String, List<String>>(2 * _map131.size); + String _key132; + List<String> _val133; + for (int _i134 = 0; _i134 < _map131.size; ++_i134) { + _key132 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list135 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val133 = new ArrayList<String>(_list135.size); + String _elem136; + for (int _i137 = 0; _i137 < _list135.size; ++_i137) { + _elem136 = iprot.readString(); + _val133.add(_elem136); + } + } + struct.success.put(_key132, _val133); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class checkURLs_args implements org.apache.thrift.TBase<checkURLs_args, checkURLs_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkURLs_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkURLs_args"); + + private static final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkURLs_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkURLs_argsTupleSchemeFactory()); + } + + public List<String> urls; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(urls); + } + + @Override + public int describeContents() { + return 0; + } + + public checkURLs_args(android.os.Parcel in) { + this.urls = new ArrayList<String>(); + in.readList(this.urls, checkURLs_args.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<checkURLs_args> CREATOR = new android.os.Parcelable.Creator<checkURLs_args>() { + @Override + public checkURLs_args[] newArray(int size) { + return new checkURLs_args[size]; + } + + @Override + public checkURLs_args createFromParcel(android.os.Parcel in) { + return new checkURLs_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + URLS((short) 1, "urls"); + + 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: // URLS + return URLS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkURLs_args.class, metaDataMap); + } + + public checkURLs_args() { + } + + public checkURLs_args( + List<String> urls) { + this(); + this.urls = urls; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkURLs_args(checkURLs_args other) { + if (other.isSetUrls()) { + this.urls = other.urls; + } + } + + public checkURLs_args deepCopy() { + return new checkURLs_args(this); + } + + @Override + public void clear() { + this.urls = null; + } + + public int getUrlsSize() { + return (this.urls == null) ? 0 : this.urls.size(); + } + + public java.util.Iterator<String> getUrlsIterator() { + return (this.urls == null) ? null : this.urls.iterator(); + } + + public void addToUrls(String elem) { + if (this.urls == null) { + this.urls = new ArrayList<String>(); + } + this.urls.add(elem); + } + + public List<String> getUrls() { + return this.urls; + } + + public checkURLs_args setUrls(List<String> urls) { + this.urls = urls; + return this; + } + + public void unsetUrls() { + this.urls = null; + } + + /** Returns true if field urls is set (has been assigned a value) and false otherwise */ + public boolean isSetUrls() { + return this.urls != null; + } + + public void setUrlsIsSet(boolean value) { + if (!value) { + this.urls = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case URLS: + if (value == null) { + unsetUrls(); + } else { + setUrls((List<String>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case URLS: + return getUrls(); + + } + 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 URLS: + return isSetUrls(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkURLs_args) + return this.equals((checkURLs_args) that); + return false; + } + + public boolean equals(checkURLs_args that) { + if (that == null) + return false; + + boolean this_present_urls = true && this.isSetUrls(); + boolean that_present_urls = true && that.isSetUrls(); + if (this_present_urls || that_present_urls) { + if (!(this_present_urls && that_present_urls)) + return false; + if (!this.urls.equals(that.urls)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_urls = true && (isSetUrls()); + list.add(present_urls); + if (present_urls) + list.add(urls); + + return list.hashCode(); + } + + @Override + public int compareTo(checkURLs_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetUrls()).compareTo(other.isSetUrls()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUrls()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, other.urls); + 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("checkURLs_args("); + boolean first = true; + + sb.append("urls:"); + if (this.urls == null) { + sb.append("null"); + } else { + sb.append(this.urls); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class checkURLs_argsStandardSchemeFactory implements SchemeFactory { + public checkURLs_argsStandardScheme getScheme() { + return new checkURLs_argsStandardScheme(); + } + } + + private static class checkURLs_argsStandardScheme extends StandardScheme<checkURLs_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkURLs_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: // URLS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list138 = iprot.readListBegin(); + struct.urls = new ArrayList<String>(_list138.size); + String _elem139; + for (int _i140 = 0; _i140 < _list138.size; ++_i140) { + _elem139 = iprot.readString(); + struct.urls.add(_elem139); + } + iprot.readListEnd(); + } + struct.setUrlsIsSet(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, checkURLs_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.urls != null) { + oprot.writeFieldBegin(URLS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); + for (String _iter141 : struct.urls) { + oprot.writeString(_iter141); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkURLs_argsTupleSchemeFactory implements SchemeFactory { + public checkURLs_argsTupleScheme getScheme() { + return new checkURLs_argsTupleScheme(); + } + } + + private static class checkURLs_argsTupleScheme extends TupleScheme<checkURLs_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkURLs_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUrls()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetUrls()) { + { + oprot.writeI32(struct.urls.size()); + for (String _iter142 : struct.urls) { + oprot.writeString(_iter142); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkURLs_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list143 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.urls = new ArrayList<String>(_list143.size); + String _elem144; + for (int _i145 = 0; _i145 < _list143.size; ++_i145) { + _elem144 = iprot.readString(); + struct.urls.add(_elem144); + } + } + struct.setUrlsIsSet(true); + } + } + } + + } + + public static class checkURLs_result implements org.apache.thrift.TBase<checkURLs_result, checkURLs_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkURLs_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkURLs_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkURLs_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkURLs_resultTupleSchemeFactory()); + } + + public Map<String, List<String>> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } + + @Override + public int describeContents() { + return 0; + } + + public checkURLs_result(android.os.Parcel in) { + this.success = new HashMap<String, List<String>>(); + in.readMap(this.success, checkURLs_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<checkURLs_result> CREATOR = new android.os.Parcelable.Creator<checkURLs_result>() { + @Override + public checkURLs_result[] newArray(int size) { + return new checkURLs_result[size]; + } + + @Override + public checkURLs_result createFromParcel(android.os.Parcel in) { + return new checkURLs_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkURLs_result.class, metaDataMap); + } + + public checkURLs_result() { + } + + public checkURLs_result( + Map<String, List<String>> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkURLs_result(checkURLs_result other) { + if (other.isSetSuccess()) { + Map<String, List<String>> __this__success = new HashMap<String, List<String>>(other.success.size()); + for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + + String other_element_key = other_element.getKey(); + List<String> other_element_value = other_element.getValue(); + + String __this__success_copy_key = other_element_key; + + List<String> __this__success_copy_value = other_element_value; + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } + + public checkURLs_result deepCopy() { + return new checkURLs_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(String key, List<String> val) { + if (this.success == null) { + this.success = new HashMap<String, List<String>>(); + } + this.success.put(key, val); + } + + public Map<String, List<String>> getSuccess() { + return this.success; + } + + public checkURLs_result setSuccess(Map<String, List<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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, List<String>>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkURLs_result) + return this.equals((checkURLs_result) that); + return false; + } + + public boolean equals(checkURLs_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(checkURLs_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("checkURLs_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, 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 checkURLs_resultStandardSchemeFactory implements SchemeFactory { + public checkURLs_resultStandardScheme getScheme() { + return new checkURLs_resultStandardScheme(); + } + } + + private static class checkURLs_resultStandardScheme extends StandardScheme<checkURLs_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkURLs_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 _map146 = iprot.readMapBegin(); + struct.success = new HashMap<String, List<String>>(2 * _map146.size); + String _key147; + List<String> _val148; + for (int _i149 = 0; _i149 < _map146.size; ++_i149) { + _key147 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list150 = iprot.readListBegin(); + _val148 = new ArrayList<String>(_list150.size); + String _elem151; + for (int _i152 = 0; _i152 < _list150.size; ++_i152) { + _elem151 = iprot.readString(); + _val148.add(_elem151); + } + iprot.readListEnd(); + } + struct.success.put(_key147, _val148); + } + iprot.readMapEnd(); + } + 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, checkURLs_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.LIST, struct.success.size())); + for (Map.Entry<String, List<String>> _iter153 : struct.success.entrySet()) { + oprot.writeString(_iter153.getKey()); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter153.getValue().size())); + for (String _iter154 : _iter153.getValue()) { + oprot.writeString(_iter154); + } + oprot.writeListEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkURLs_resultTupleSchemeFactory implements SchemeFactory { + public checkURLs_resultTupleScheme getScheme() { + return new checkURLs_resultTupleScheme(); + } + } + + private static class checkURLs_resultTupleScheme extends TupleScheme<checkURLs_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkURLs_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, List<String>> _iter155 : struct.success.entrySet()) { + oprot.writeString(_iter155.getKey()); + { + oprot.writeI32(_iter155.getValue().size()); + for (String _iter156 : _iter155.getValue()) { + oprot.writeString(_iter156); + } + } + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkURLs_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map157 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.success = new HashMap<String, List<String>>(2 * _map157.size); + String _key158; + List<String> _val159; + for (int _i160 = 0; _i160 < _map157.size; ++_i160) { + _key158 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list161 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val159 = new ArrayList<String>(_list161.size); + String _elem162; + for (int _i163 = 0; _i163 < _list161.size; ++_i163) { + _elem162 = iprot.readString(); + _val159.add(_elem162); + } + } + struct.success.put(_key158, _val159); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class parseURLs_args implements org.apache.thrift.TBase<parseURLs_args, parseURLs_args._Fields>, java.io.Serializable, Cloneable, Comparable<parseURLs_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("parseURLs_args"); + + private static final org.apache.thrift.protocol.TField HTML_FIELD_DESC = new org.apache.thrift.protocol.TField("html", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField URL_FIELD_DESC = new org.apache.thrift.protocol.TField("url", org.apache.thrift.protocol.TType.STRING, (short) 2); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new parseURLs_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new parseURLs_argsTupleSchemeFactory()); + } + + public String html; // required + public String url; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(html); + out.writeString(url); + } + + @Override + public int describeContents() { + return 0; + } + + public parseURLs_args(android.os.Parcel in) { + this.html = in.readString(); + this.url = in.readString(); + } + + public static final android.os.Parcelable.Creator<parseURLs_args> CREATOR = new android.os.Parcelable.Creator<parseURLs_args>() { + @Override + public parseURLs_args[] newArray(int size) { + return new parseURLs_args[size]; + } + + @Override + public parseURLs_args createFromParcel(android.os.Parcel in) { + return new parseURLs_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + HTML((short) 1, "html"), + URL((short) 2, "url"); + + 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: // HTML + return HTML; + case 2: // URL + return URL; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.HTML, new org.apache.thrift.meta_data.FieldMetaData("html", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.URL, new org.apache.thrift.meta_data.FieldMetaData("url", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(parseURLs_args.class, metaDataMap); + } + + public parseURLs_args() { + } + + public parseURLs_args( + String html, + String url) { + this(); + this.html = html; + this.url = url; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public parseURLs_args(parseURLs_args other) { + if (other.isSetHtml()) { + this.html = other.html; + } + if (other.isSetUrl()) { + this.url = other.url; + } + } + + public parseURLs_args deepCopy() { + return new parseURLs_args(this); + } + + @Override + public void clear() { + this.html = null; + this.url = null; + } + + public String getHtml() { + return this.html; + } + + public parseURLs_args setHtml(String html) { + this.html = html; + return this; + } + + public void unsetHtml() { + this.html = null; + } + + /** Returns true if field html is set (has been assigned a value) and false otherwise */ + public boolean isSetHtml() { + return this.html != null; + } + + public void setHtmlIsSet(boolean value) { + if (!value) { + this.html = null; + } + } + + public String getUrl() { + return this.url; + } + + public parseURLs_args setUrl(String url) { + this.url = url; + return this; + } + + public void unsetUrl() { + this.url = null; + } + + /** Returns true if field url is set (has been assigned a value) and false otherwise */ + public boolean isSetUrl() { + return this.url != null; + } + + public void setUrlIsSet(boolean value) { + if (!value) { + this.url = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case HTML: + if (value == null) { + unsetHtml(); + } else { + setHtml((String) value); + } + break; + + case URL: + if (value == null) { + unsetUrl(); + } else { + setUrl((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case HTML: + return getHtml(); + + case URL: + return getUrl(); + + } + 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 HTML: + return isSetHtml(); + case URL: + return isSetUrl(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof parseURLs_args) + return this.equals((parseURLs_args) that); + return false; + } + + public boolean equals(parseURLs_args that) { + if (that == null) + return false; + + boolean this_present_html = true && this.isSetHtml(); + boolean that_present_html = true && that.isSetHtml(); + if (this_present_html || that_present_html) { + if (!(this_present_html && that_present_html)) + return false; + if (!this.html.equals(that.html)) + return false; + } + + boolean this_present_url = true && this.isSetUrl(); + boolean that_present_url = true && that.isSetUrl(); + if (this_present_url || that_present_url) { + if (!(this_present_url && that_present_url)) + return false; + if (!this.url.equals(that.url)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_html = true && (isSetHtml()); + list.add(present_html); + if (present_html) + list.add(html); + + boolean present_url = true && (isSetUrl()); + list.add(present_url); + if (present_url) + list.add(url); + + return list.hashCode(); + } + + @Override + public int compareTo(parseURLs_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetHtml()).compareTo(other.isSetHtml()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetHtml()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.html, other.html); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetUrl()).compareTo(other.isSetUrl()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUrl()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.url, other.url); + 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("parseURLs_args("); + boolean first = true; + + sb.append("html:"); + if (this.html == null) { + sb.append("null"); + } else { + sb.append(this.html); + } + first = false; + if (!first) sb.append(", "); + sb.append("url:"); + if (this.url == null) { + sb.append("null"); + } else { + sb.append(this.url); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class parseURLs_argsStandardSchemeFactory implements SchemeFactory { + public parseURLs_argsStandardScheme getScheme() { + return new parseURLs_argsStandardScheme(); + } + } + + private static class parseURLs_argsStandardScheme extends StandardScheme<parseURLs_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, parseURLs_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: // HTML + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.html = iprot.readString(); + struct.setHtmlIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // URL + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.url = iprot.readString(); + struct.setUrlIsSet(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, parseURLs_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.html != null) { + oprot.writeFieldBegin(HTML_FIELD_DESC); + oprot.writeString(struct.html); + oprot.writeFieldEnd(); + } + if (struct.url != null) { + oprot.writeFieldBegin(URL_FIELD_DESC); + oprot.writeString(struct.url); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class parseURLs_argsTupleSchemeFactory implements SchemeFactory { + public parseURLs_argsTupleScheme getScheme() { + return new parseURLs_argsTupleScheme(); + } + } + + private static class parseURLs_argsTupleScheme extends TupleScheme<parseURLs_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, parseURLs_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetHtml()) { + optionals.set(0); + } + if (struct.isSetUrl()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetHtml()) { + oprot.writeString(struct.html); + } + if (struct.isSetUrl()) { + oprot.writeString(struct.url); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, parseURLs_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.html = iprot.readString(); + struct.setHtmlIsSet(true); + } + if (incoming.get(1)) { + struct.url = iprot.readString(); + struct.setUrlIsSet(true); + } + } + } + + } + + public static class parseURLs_result implements org.apache.thrift.TBase<parseURLs_result, parseURLs_result._Fields>, java.io.Serializable, Cloneable, Comparable<parseURLs_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("parseURLs_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new parseURLs_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new parseURLs_resultTupleSchemeFactory()); + } + + public Map<String, List<String>> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } + + @Override + public int describeContents() { + return 0; + } + + public parseURLs_result(android.os.Parcel in) { + this.success = new HashMap<String, List<String>>(); + in.readMap(this.success, parseURLs_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<parseURLs_result> CREATOR = new android.os.Parcelable.Creator<parseURLs_result>() { + @Override + public parseURLs_result[] newArray(int size) { + return new parseURLs_result[size]; + } + + @Override + public parseURLs_result createFromParcel(android.os.Parcel in) { + return new parseURLs_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(parseURLs_result.class, metaDataMap); + } + + public parseURLs_result() { + } + + public parseURLs_result( + Map<String, List<String>> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public parseURLs_result(parseURLs_result other) { + if (other.isSetSuccess()) { + Map<String, List<String>> __this__success = new HashMap<String, List<String>>(other.success.size()); + for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + + String other_element_key = other_element.getKey(); + List<String> other_element_value = other_element.getValue(); + + String __this__success_copy_key = other_element_key; + + List<String> __this__success_copy_value = other_element_value; + + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } + + public parseURLs_result deepCopy() { + return new parseURLs_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public void putToSuccess(String key, List<String> val) { + if (this.success == null) { + this.success = new HashMap<String, List<String>>(); + } + this.success.put(key, val); + } + + public Map<String, List<String>> getSuccess() { + return this.success; + } + + public parseURLs_result setSuccess(Map<String, List<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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, List<String>>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof parseURLs_result) + return this.equals((parseURLs_result) that); + return false; + } + + public boolean equals(parseURLs_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(parseURLs_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("parseURLs_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, 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 parseURLs_resultStandardSchemeFactory implements SchemeFactory { + public parseURLs_resultStandardScheme getScheme() { + return new parseURLs_resultStandardScheme(); + } + } + + private static class parseURLs_resultStandardScheme extends StandardScheme<parseURLs_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, parseURLs_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 _map164 = iprot.readMapBegin(); + struct.success = new HashMap<String, List<String>>(2 * _map164.size); + String _key165; + List<String> _val166; + for (int _i167 = 0; _i167 < _map164.size; ++_i167) { + _key165 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list168 = iprot.readListBegin(); + _val166 = new ArrayList<String>(_list168.size); + String _elem169; + for (int _i170 = 0; _i170 < _list168.size; ++_i170) { + _elem169 = iprot.readString(); + _val166.add(_elem169); + } + iprot.readListEnd(); + } + struct.success.put(_key165, _val166); + } + iprot.readMapEnd(); + } + 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, parseURLs_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.LIST, struct.success.size())); + for (Map.Entry<String, List<String>> _iter171 : struct.success.entrySet()) { + oprot.writeString(_iter171.getKey()); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter171.getValue().size())); + for (String _iter172 : _iter171.getValue()) { + oprot.writeString(_iter172); + } + oprot.writeListEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class parseURLs_resultTupleSchemeFactory implements SchemeFactory { + public parseURLs_resultTupleScheme getScheme() { + return new parseURLs_resultTupleScheme(); + } + } + + private static class parseURLs_resultTupleScheme extends TupleScheme<parseURLs_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, parseURLs_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, List<String>> _iter173 : struct.success.entrySet()) { + oprot.writeString(_iter173.getKey()); + { + oprot.writeI32(_iter173.getValue().size()); + for (String _iter174 : _iter173.getValue()) { + oprot.writeString(_iter174); + } + } + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, parseURLs_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map175 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); + struct.success = new HashMap<String, List<String>>(2 * _map175.size); + String _key176; + List<String> _val177; + for (int _i178 = 0; _i178 < _map175.size; ++_i178) { + _key176 = iprot.readString(); + { + org.apache.thrift.protocol.TList _list179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val177 = new ArrayList<String>(_list179.size); + String _elem180; + for (int _i181 = 0; _i181 < _list179.size; ++_i181) { + _elem180 = iprot.readString(); + _val177.add(_elem180); + } + } + struct.success.put(_key176, _val177); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class checkOnlineStatus_args implements org.apache.thrift.TBase<checkOnlineStatus_args, checkOnlineStatus_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkOnlineStatus_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatus_args"); + + private static final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkOnlineStatus_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkOnlineStatus_argsTupleSchemeFactory()); + } + + public List<String> urls; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(urls); + } + + @Override + public int describeContents() { + return 0; + } + + public checkOnlineStatus_args(android.os.Parcel in) { + this.urls = new ArrayList<String>(); + in.readList(this.urls, checkOnlineStatus_args.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<checkOnlineStatus_args> CREATOR = new android.os.Parcelable.Creator<checkOnlineStatus_args>() { + @Override + public checkOnlineStatus_args[] newArray(int size) { + return new checkOnlineStatus_args[size]; + } + + @Override + public checkOnlineStatus_args createFromParcel(android.os.Parcel in) { + return new checkOnlineStatus_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + URLS((short) 1, "urls"); + + 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: // URLS + return URLS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatus_args.class, metaDataMap); + } + + public checkOnlineStatus_args() { + } + + public checkOnlineStatus_args( + List<String> urls) { + this(); + this.urls = urls; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkOnlineStatus_args(checkOnlineStatus_args other) { + if (other.isSetUrls()) { + this.urls = other.urls; + } + } + + public checkOnlineStatus_args deepCopy() { + return new checkOnlineStatus_args(this); + } + + @Override + public void clear() { + this.urls = null; + } + + public int getUrlsSize() { + return (this.urls == null) ? 0 : this.urls.size(); + } + + public java.util.Iterator<String> getUrlsIterator() { + return (this.urls == null) ? null : this.urls.iterator(); + } + + public void addToUrls(String elem) { + if (this.urls == null) { + this.urls = new ArrayList<String>(); + } + this.urls.add(elem); + } + + public List<String> getUrls() { + return this.urls; + } + + public checkOnlineStatus_args setUrls(List<String> urls) { + this.urls = urls; + return this; + } + + public void unsetUrls() { + this.urls = null; + } + + /** Returns true if field urls is set (has been assigned a value) and false otherwise */ + public boolean isSetUrls() { + return this.urls != null; + } + + public void setUrlsIsSet(boolean value) { + if (!value) { + this.urls = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case URLS: + if (value == null) { + unsetUrls(); + } else { + setUrls((List<String>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case URLS: + return getUrls(); + + } + 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 URLS: + return isSetUrls(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkOnlineStatus_args) + return this.equals((checkOnlineStatus_args) that); + return false; + } + + public boolean equals(checkOnlineStatus_args that) { + if (that == null) + return false; + + boolean this_present_urls = true && this.isSetUrls(); + boolean that_present_urls = true && that.isSetUrls(); + if (this_present_urls || that_present_urls) { + if (!(this_present_urls && that_present_urls)) + return false; + if (!this.urls.equals(that.urls)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_urls = true && (isSetUrls()); + list.add(present_urls); + if (present_urls) + list.add(urls); + + return list.hashCode(); + } + + @Override + public int compareTo(checkOnlineStatus_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetUrls()).compareTo(other.isSetUrls()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUrls()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, other.urls); + 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("checkOnlineStatus_args("); + boolean first = true; + + sb.append("urls:"); + if (this.urls == null) { + sb.append("null"); + } else { + sb.append(this.urls); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private static class checkOnlineStatus_argsStandardSchemeFactory implements SchemeFactory { + public checkOnlineStatus_argsStandardScheme getScheme() { + return new checkOnlineStatus_argsStandardScheme(); + } + } + + private static class checkOnlineStatus_argsStandardScheme extends StandardScheme<checkOnlineStatus_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatus_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: // URLS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list182 = iprot.readListBegin(); + struct.urls = new ArrayList<String>(_list182.size); + String _elem183; + for (int _i184 = 0; _i184 < _list182.size; ++_i184) { + _elem183 = iprot.readString(); + struct.urls.add(_elem183); + } + iprot.readListEnd(); + } + struct.setUrlsIsSet(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, checkOnlineStatus_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.urls != null) { + oprot.writeFieldBegin(URLS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); + for (String _iter185 : struct.urls) { + oprot.writeString(_iter185); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkOnlineStatus_argsTupleSchemeFactory implements SchemeFactory { + public checkOnlineStatus_argsTupleScheme getScheme() { + return new checkOnlineStatus_argsTupleScheme(); + } + } + + private static class checkOnlineStatus_argsTupleScheme extends TupleScheme<checkOnlineStatus_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUrls()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetUrls()) { + { + oprot.writeI32(struct.urls.size()); + for (String _iter186 : struct.urls) { + oprot.writeString(_iter186); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list187 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.urls = new ArrayList<String>(_list187.size); + String _elem188; + for (int _i189 = 0; _i189 < _list187.size; ++_i189) { + _elem188 = iprot.readString(); + struct.urls.add(_elem188); + } + } + struct.setUrlsIsSet(true); + } + } + } + + } + + public static class checkOnlineStatus_result implements org.apache.thrift.TBase<checkOnlineStatus_result, checkOnlineStatus_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkOnlineStatus_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatus_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkOnlineStatus_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkOnlineStatus_resultTupleSchemeFactory()); + } + + public OnlineCheck success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } + + @Override + public int describeContents() { + return 0; + } + + public checkOnlineStatus_result(android.os.Parcel in) { + this.success = in.readParcelable(checkOnlineStatus_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<checkOnlineStatus_result> CREATOR = new android.os.Parcelable.Creator<checkOnlineStatus_result>() { + @Override + public checkOnlineStatus_result[] newArray(int size) { + return new checkOnlineStatus_result[size]; + } + + @Override + public checkOnlineStatus_result createFromParcel(android.os.Parcel in) { + return new checkOnlineStatus_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatus_result.class, metaDataMap); + } + + public checkOnlineStatus_result() { + } + + public checkOnlineStatus_result( + OnlineCheck success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkOnlineStatus_result(checkOnlineStatus_result other) { + if (other.isSetSuccess()) { + this.success = new OnlineCheck(other.success); + } + } + + public checkOnlineStatus_result deepCopy() { + return new checkOnlineStatus_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public OnlineCheck getSuccess() { + return this.success; + } + + public checkOnlineStatus_result setSuccess(OnlineCheck 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((OnlineCheck) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkOnlineStatus_result) + return this.equals((checkOnlineStatus_result) that); + return false; + } + + public boolean equals(checkOnlineStatus_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(checkOnlineStatus_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("checkOnlineStatus_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 + 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, 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 checkOnlineStatus_resultStandardSchemeFactory implements SchemeFactory { + public checkOnlineStatus_resultStandardScheme getScheme() { + return new checkOnlineStatus_resultStandardScheme(); + } + } + + private static class checkOnlineStatus_resultStandardScheme extends StandardScheme<checkOnlineStatus_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatus_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 OnlineCheck(); + struct.success.read(iprot); + 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, checkOnlineStatus_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkOnlineStatus_resultTupleSchemeFactory implements SchemeFactory { + public checkOnlineStatus_resultTupleScheme getScheme() { + return new checkOnlineStatus_resultTupleScheme(); + } + } + + private static class checkOnlineStatus_resultTupleScheme extends TupleScheme<checkOnlineStatus_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new OnlineCheck(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class checkOnlineStatusContainer_args implements org.apache.thrift.TBase<checkOnlineStatusContainer_args, checkOnlineStatusContainer_args._Fields>, java.io.Serializable, Cloneable, Comparable<checkOnlineStatusContainer_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatusContainer_args"); + + private static final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short) 1); + private static final org.apache.thrift.protocol.TField FILENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("filename", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short) 3); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkOnlineStatusContainer_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkOnlineStatusContainer_argsTupleSchemeFactory()); + } + + public List<String> urls; // required + public String filename; // required + public ByteBuffer data; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(urls); + out.writeString(filename); + out.writeInt(data != null ? 1 : 0); + if (data != null) { + out.writeByteArray(data.array(), data.position() + data.arrayOffset(), data.limit() - data.position()); + } + } + + @Override + public int describeContents() { + return 0; + } + + public checkOnlineStatusContainer_args(android.os.Parcel in) { + this.urls = new ArrayList<String>(); + in.readList(this.urls, checkOnlineStatusContainer_args.class.getClassLoader()); + this.filename = in.readString(); + if (in.readInt() == 1) { + this.data = ByteBuffer.wrap(in.createByteArray()); + } + } + + public static final android.os.Parcelable.Creator<checkOnlineStatusContainer_args> CREATOR = new android.os.Parcelable.Creator<checkOnlineStatusContainer_args>() { + @Override + public checkOnlineStatusContainer_args[] newArray(int size) { + return new checkOnlineStatusContainer_args[size]; + } + + @Override + public checkOnlineStatusContainer_args createFromParcel(android.os.Parcel in) { + return new checkOnlineStatusContainer_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + URLS((short) 1, "urls"), + FILENAME((short) 2, "filename"), + DATA((short) 3, "data"); + + 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: // URLS + return URLS; + case 2: // FILENAME + return FILENAME; + case 3: // DATA + return DATA; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + tmpMap.put(_Fields.FILENAME, new org.apache.thrift.meta_data.FieldMetaData("filename", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, true))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatusContainer_args.class, metaDataMap); + } + + public checkOnlineStatusContainer_args() { + } + + public checkOnlineStatusContainer_args( + List<String> urls, + String filename, + ByteBuffer data) { + this(); + this.urls = urls; + this.filename = filename; + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkOnlineStatusContainer_args(checkOnlineStatusContainer_args other) { + if (other.isSetUrls()) { + this.urls = other.urls; + } + if (other.isSetFilename()) { + this.filename = other.filename; + } + if (other.isSetData()) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); + } + } + + public checkOnlineStatusContainer_args deepCopy() { + return new checkOnlineStatusContainer_args(this); + } + + @Override + public void clear() { + this.urls = null; + this.filename = null; + this.data = null; + } + + public int getUrlsSize() { + return (this.urls == null) ? 0 : this.urls.size(); + } + + public java.util.Iterator<String> getUrlsIterator() { + return (this.urls == null) ? null : this.urls.iterator(); + } + + public void addToUrls(String elem) { + if (this.urls == null) { + this.urls = new ArrayList<String>(); + } + this.urls.add(elem); + } + + public List<String> getUrls() { + return this.urls; + } + + public checkOnlineStatusContainer_args setUrls(List<String> urls) { + this.urls = urls; + return this; + } + + public void unsetUrls() { + this.urls = null; + } + + /** Returns true if field urls is set (has been assigned a value) and false otherwise */ + public boolean isSetUrls() { + return this.urls != null; + } + + public void setUrlsIsSet(boolean value) { + if (!value) { + this.urls = null; + } + } + + public String getFilename() { + return this.filename; + } + + public checkOnlineStatusContainer_args setFilename(String filename) { + this.filename = filename; + return this; + } + + public void unsetFilename() { + this.filename = null; + } + + /** Returns true if field filename is set (has been assigned a value) and false otherwise */ + public boolean isSetFilename() { + return this.filename != null; + } + + public void setFilenameIsSet(boolean value) { + if (!value) { + this.filename = null; + } + } + + public byte[] getData() { + setData(org.apache.thrift.TBaseHelper.rightSize(data)); + return data == null ? null : data.array(); + } + + public ByteBuffer bufferForData() { + return org.apache.thrift.TBaseHelper.copyBinary(data); + } + + public checkOnlineStatusContainer_args setData(byte[] data) { + this.data = data == null ? (ByteBuffer) null : ByteBuffer.wrap(Arrays.copyOf(data, data.length)); + return this; + } + + public checkOnlineStatusContainer_args setData(ByteBuffer data) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + return this; + } + + public void unsetData() { + this.data = null; + } + + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } + + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case URLS: + if (value == null) { + unsetUrls(); + } else { + setUrls((List<String>) value); + } + break; + + case FILENAME: + if (value == null) { + unsetFilename(); + } else { + setFilename((String) value); + } + break; + + case DATA: + if (value == null) { + unsetData(); + } else { + setData((ByteBuffer) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case URLS: + return getUrls(); + + case FILENAME: + return getFilename(); + + case DATA: + return getData(); + + } + 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 URLS: + return isSetUrls(); + case FILENAME: + return isSetFilename(); + case DATA: + return isSetData(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkOnlineStatusContainer_args) + return this.equals((checkOnlineStatusContainer_args) that); + return false; + } + + public boolean equals(checkOnlineStatusContainer_args that) { + if (that == null) + return false; + + boolean this_present_urls = true && this.isSetUrls(); + boolean that_present_urls = true && that.isSetUrls(); + if (this_present_urls || that_present_urls) { + if (!(this_present_urls && that_present_urls)) + return false; + if (!this.urls.equals(that.urls)) + return false; + } + + boolean this_present_filename = true && this.isSetFilename(); + boolean that_present_filename = true && that.isSetFilename(); + if (this_present_filename || that_present_filename) { + if (!(this_present_filename && that_present_filename)) + return false; + if (!this.filename.equals(that.filename)) + return false; + } + + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_urls = true && (isSetUrls()); + list.add(present_urls); + if (present_urls) + list.add(urls); + + boolean present_filename = true && (isSetFilename()); + list.add(present_filename); + if (present_filename) + list.add(filename); + + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); + + return list.hashCode(); + } + + @Override + public int compareTo(checkOnlineStatusContainer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetUrls()).compareTo(other.isSetUrls()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUrls()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, other.urls); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFilename()).compareTo(other.isSetFilename()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFilename()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filename, other.filename); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + 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("checkOnlineStatusContainer_args("); + boolean first = true; + + sb.append("urls:"); + if (this.urls == null) { + sb.append("null"); + } else { + sb.append(this.urls); + } + first = false; + if (!first) sb.append(", "); + sb.append("filename:"); + if (this.filename == null) { + sb.append("null"); + } else { + sb.append(this.filename); + } + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.data, 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, 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 checkOnlineStatusContainer_argsStandardSchemeFactory implements SchemeFactory { + public checkOnlineStatusContainer_argsStandardScheme getScheme() { + return new checkOnlineStatusContainer_argsStandardScheme(); + } + } + + private static class checkOnlineStatusContainer_argsStandardScheme extends StandardScheme<checkOnlineStatusContainer_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatusContainer_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: // URLS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list190 = iprot.readListBegin(); + struct.urls = new ArrayList<String>(_list190.size); + String _elem191; + for (int _i192 = 0; _i192 < _list190.size; ++_i192) { + _elem191 = iprot.readString(); + struct.urls.add(_elem191); + } + iprot.readListEnd(); + } + struct.setUrlsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // FILENAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.filename = iprot.readString(); + struct.setFilenameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(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, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.urls != null) { + oprot.writeFieldBegin(URLS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); + for (String _iter193 : struct.urls) { + oprot.writeString(_iter193); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.filename != null) { + oprot.writeFieldBegin(FILENAME_FIELD_DESC); + oprot.writeString(struct.filename); + oprot.writeFieldEnd(); + } + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + oprot.writeBinary(struct.data); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkOnlineStatusContainer_argsTupleSchemeFactory implements SchemeFactory { + public checkOnlineStatusContainer_argsTupleScheme getScheme() { + return new checkOnlineStatusContainer_argsTupleScheme(); + } + } + + private static class checkOnlineStatusContainer_argsTupleScheme extends TupleScheme<checkOnlineStatusContainer_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUrls()) { + optionals.set(0); + } + if (struct.isSetFilename()) { + optionals.set(1); + } + if (struct.isSetData()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetUrls()) { + { + oprot.writeI32(struct.urls.size()); + for (String _iter194 : struct.urls) { + oprot.writeString(_iter194); + } + } + } + if (struct.isSetFilename()) { + oprot.writeString(struct.filename); + } + if (struct.isSetData()) { + oprot.writeBinary(struct.data); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.urls = new ArrayList<String>(_list195.size); + String _elem196; + for (int _i197 = 0; _i197 < _list195.size; ++_i197) { + _elem196 = iprot.readString(); + struct.urls.add(_elem196); + } + } + struct.setUrlsIsSet(true); + } + if (incoming.get(1)) { + struct.filename = iprot.readString(); + struct.setFilenameIsSet(true); + } + if (incoming.get(2)) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(true); + } + } + } + + } + + public static class checkOnlineStatusContainer_result implements org.apache.thrift.TBase<checkOnlineStatusContainer_result, checkOnlineStatusContainer_result._Fields>, java.io.Serializable, Cloneable, Comparable<checkOnlineStatusContainer_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatusContainer_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new checkOnlineStatusContainer_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new checkOnlineStatusContainer_resultTupleSchemeFactory()); + } + + public OnlineCheck success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } + + @Override + public int describeContents() { + return 0; + } + + public checkOnlineStatusContainer_result(android.os.Parcel in) { + this.success = in.readParcelable(checkOnlineStatusContainer_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<checkOnlineStatusContainer_result> CREATOR = new android.os.Parcelable.Creator<checkOnlineStatusContainer_result>() { + @Override + public checkOnlineStatusContainer_result[] newArray(int size) { + return new checkOnlineStatusContainer_result[size]; + } + + @Override + public checkOnlineStatusContainer_result createFromParcel(android.os.Parcel in) { + return new checkOnlineStatusContainer_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatusContainer_result.class, metaDataMap); + } + + public checkOnlineStatusContainer_result() { + } + + public checkOnlineStatusContainer_result( + OnlineCheck success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public checkOnlineStatusContainer_result(checkOnlineStatusContainer_result other) { + if (other.isSetSuccess()) { + this.success = new OnlineCheck(other.success); + } + } + + public checkOnlineStatusContainer_result deepCopy() { + return new checkOnlineStatusContainer_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public OnlineCheck getSuccess() { + return this.success; + } + + public checkOnlineStatusContainer_result setSuccess(OnlineCheck 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((OnlineCheck) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof checkOnlineStatusContainer_result) + return this.equals((checkOnlineStatusContainer_result) that); + return false; + } + + public boolean equals(checkOnlineStatusContainer_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(checkOnlineStatusContainer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("checkOnlineStatusContainer_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 + 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, 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 checkOnlineStatusContainer_resultStandardSchemeFactory implements SchemeFactory { + public checkOnlineStatusContainer_resultStandardScheme getScheme() { + return new checkOnlineStatusContainer_resultStandardScheme(); + } + } + + private static class checkOnlineStatusContainer_resultStandardScheme extends StandardScheme<checkOnlineStatusContainer_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatusContainer_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 OnlineCheck(); + struct.success.read(iprot); + 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, checkOnlineStatusContainer_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class checkOnlineStatusContainer_resultTupleSchemeFactory implements SchemeFactory { + public checkOnlineStatusContainer_resultTupleScheme getScheme() { + return new checkOnlineStatusContainer_resultTupleScheme(); + } + } + + private static class checkOnlineStatusContainer_resultTupleScheme extends TupleScheme<checkOnlineStatusContainer_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new OnlineCheck(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class pollResults_args implements org.apache.thrift.TBase<pollResults_args, pollResults_args._Fields>, java.io.Serializable, Cloneable, Comparable<pollResults_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pollResults_args"); + + private static final org.apache.thrift.protocol.TField RID_FIELD_DESC = new org.apache.thrift.protocol.TField("rid", org.apache.thrift.protocol.TType.I32, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new pollResults_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pollResults_argsTupleSchemeFactory()); + } + + public int rid; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(rid); + } + + @Override + public int describeContents() { + return 0; + } + + public pollResults_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.rid = in.readInt(); + } + + public static final android.os.Parcelable.Creator<pollResults_args> CREATOR = new android.os.Parcelable.Creator<pollResults_args>() { + @Override + public pollResults_args[] newArray(int size) { + return new pollResults_args[size]; + } + + @Override + public pollResults_args createFromParcel(android.os.Parcel in) { + return new pollResults_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + RID((short) 1, "rid"); + + 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: // RID + return RID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __RID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.RID, new org.apache.thrift.meta_data.FieldMetaData("rid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "ResultID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pollResults_args.class, metaDataMap); + } + + public pollResults_args() { + } + + public pollResults_args( + int rid) { + this(); + this.rid = rid; + setRidIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public pollResults_args(pollResults_args other) { + __isset_bitfield = other.__isset_bitfield; + this.rid = other.rid; + } + + public pollResults_args deepCopy() { + return new pollResults_args(this); + } + + @Override + public void clear() { + setRidIsSet(false); + this.rid = 0; + } + + public int getRid() { + return this.rid; + } + + public pollResults_args setRid(int rid) { + this.rid = rid; + setRidIsSet(true); + return this; + } + + public void unsetRid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __RID_ISSET_ID); + } + + /** Returns true if field rid is set (has been assigned a value) and false otherwise */ + public boolean isSetRid() { + return EncodingUtils.testBit(__isset_bitfield, __RID_ISSET_ID); + } + + public void setRidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __RID_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case RID: + if (value == null) { + unsetRid(); + } else { + setRid((Integer) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case RID: + return getRid(); + + } + 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 RID: + return isSetRid(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pollResults_args) + return this.equals((pollResults_args) that); + return false; + } + + public boolean equals(pollResults_args that) { + if (that == null) + return false; + + boolean this_present_rid = true; + boolean that_present_rid = true; + if (this_present_rid || that_present_rid) { + if (!(this_present_rid && that_present_rid)) + return false; + if (this.rid != that.rid) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_rid = true; + list.add(present_rid); + if (present_rid) + list.add(rid); + + return list.hashCode(); + } + + @Override + public int compareTo(pollResults_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetRid()).compareTo(other.isSetRid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rid, other.rid); + 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("pollResults_args("); + boolean first = true; + + sb.append("rid:"); + sb.append(this.rid); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 pollResults_argsStandardSchemeFactory implements SchemeFactory { + public pollResults_argsStandardScheme getScheme() { + return new pollResults_argsStandardScheme(); + } + } + + private static class pollResults_argsStandardScheme extends StandardScheme<pollResults_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, pollResults_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: // RID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.rid = iprot.readI32(); + struct.setRidIsSet(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, pollResults_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(RID_FIELD_DESC); + oprot.writeI32(struct.rid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class pollResults_argsTupleSchemeFactory implements SchemeFactory { + public pollResults_argsTupleScheme getScheme() { + return new pollResults_argsTupleScheme(); + } + } + + private static class pollResults_argsTupleScheme extends TupleScheme<pollResults_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pollResults_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRid()) { + oprot.writeI32(struct.rid); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pollResults_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.rid = iprot.readI32(); + struct.setRidIsSet(true); + } + } + } + + } + + public static class pollResults_result implements org.apache.thrift.TBase<pollResults_result, pollResults_result._Fields>, java.io.Serializable, Cloneable, Comparable<pollResults_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pollResults_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new pollResults_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pollResults_resultTupleSchemeFactory()); + } + + public OnlineCheck success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } + + @Override + public int describeContents() { + return 0; + } + + public pollResults_result(android.os.Parcel in) { + this.success = in.readParcelable(pollResults_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<pollResults_result> CREATOR = new android.os.Parcelable.Creator<pollResults_result>() { + @Override + public pollResults_result[] newArray(int size) { + return new pollResults_result[size]; + } + + @Override + public pollResults_result createFromParcel(android.os.Parcel in) { + return new pollResults_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pollResults_result.class, metaDataMap); + } + + public pollResults_result() { + } + + public pollResults_result( + OnlineCheck success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public pollResults_result(pollResults_result other) { + if (other.isSetSuccess()) { + this.success = new OnlineCheck(other.success); + } + } + + public pollResults_result deepCopy() { + return new pollResults_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public OnlineCheck getSuccess() { + return this.success; + } + + public pollResults_result setSuccess(OnlineCheck 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((OnlineCheck) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pollResults_result) + return this.equals((pollResults_result) that); + return false; + } + + public boolean equals(pollResults_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(pollResults_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("pollResults_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 + 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, 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 pollResults_resultStandardSchemeFactory implements SchemeFactory { + public pollResults_resultStandardScheme getScheme() { + return new pollResults_resultStandardScheme(); + } + } + + private static class pollResults_resultStandardScheme extends StandardScheme<pollResults_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, pollResults_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 OnlineCheck(); + struct.success.read(iprot); + 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, pollResults_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class pollResults_resultTupleSchemeFactory implements SchemeFactory { + public pollResults_resultTupleScheme getScheme() { + return new pollResults_resultTupleScheme(); + } + } + + private static class pollResults_resultTupleScheme extends TupleScheme<pollResults_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pollResults_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pollResults_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new OnlineCheck(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class statusDownloads_args implements org.apache.thrift.TBase<statusDownloads_args, statusDownloads_args._Fields>, java.io.Serializable, Cloneable, Comparable<statusDownloads_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusDownloads_args"); + + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new statusDownloads_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new statusDownloads_argsTupleSchemeFactory()); + } + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } + + public statusDownloads_args(android.os.Parcel in) { + } + + public static final android.os.Parcelable.Creator<statusDownloads_args> CREATOR = new android.os.Parcelable.Creator<statusDownloads_args>() { + @Override + public statusDownloads_args[] newArray(int size) { + return new statusDownloads_args[size]; + } + + @Override + public statusDownloads_args createFromParcel(android.os.Parcel in) { + return new statusDownloads_args(in); + } + }; + + /** 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 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) { + 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; + } + } + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusDownloads_args.class, metaDataMap); + } + + public statusDownloads_args() { + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public statusDownloads_args(statusDownloads_args other) { + } + + public statusDownloads_args deepCopy() { + return new statusDownloads_args(this); + } + + @Override + public void clear() { + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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) { + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof statusDownloads_args) + return this.equals((statusDownloads_args) that); + return false; + } + + public boolean equals(statusDownloads_args that) { + if (that == null) + return false; + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); + } + + @Override + public int compareTo(statusDownloads_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + 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("statusDownloads_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, 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 statusDownloads_argsStandardSchemeFactory implements SchemeFactory { + public statusDownloads_argsStandardScheme getScheme() { + return new statusDownloads_argsStandardScheme(); + } + } + + private static class statusDownloads_argsStandardScheme extends StandardScheme<statusDownloads_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, statusDownloads_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, statusDownloads_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class statusDownloads_argsTupleSchemeFactory implements SchemeFactory { + public statusDownloads_argsTupleScheme getScheme() { + return new statusDownloads_argsTupleScheme(); + } + } + + private static class statusDownloads_argsTupleScheme extends TupleScheme<statusDownloads_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, statusDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, statusDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + + } + + public static class statusDownloads_result implements org.apache.thrift.TBase<statusDownloads_result, statusDownloads_result._Fields>, java.io.Serializable, Cloneable, Comparable<statusDownloads_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusDownloads_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new statusDownloads_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new statusDownloads_resultTupleSchemeFactory()); + } + + public List<DownloadInfo> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } + + @Override + public int describeContents() { + return 0; + } + + public statusDownloads_result(android.os.Parcel in) { + this.success = new ArrayList<DownloadInfo>(); + in.readTypedList(this.success, DownloadInfo.CREATOR); + } + + public static final android.os.Parcelable.Creator<statusDownloads_result> CREATOR = new android.os.Parcelable.Creator<statusDownloads_result>() { + @Override + public statusDownloads_result[] newArray(int size) { + return new statusDownloads_result[size]; + } + + @Override + public statusDownloads_result createFromParcel(android.os.Parcel in) { + return new statusDownloads_result(in); + } + }; + + /** 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DownloadInfo.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusDownloads_result.class, metaDataMap); + } + + public statusDownloads_result() { + } + + public statusDownloads_result( + List<DownloadInfo> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public statusDownloads_result(statusDownloads_result other) { + if (other.isSetSuccess()) { + List<DownloadInfo> __this__success = new ArrayList<DownloadInfo>(other.success.size()); + for (DownloadInfo other_element : other.success) { + __this__success.add(new DownloadInfo(other_element)); + } + this.success = __this__success; + } + } + + public statusDownloads_result deepCopy() { + return new statusDownloads_result(this); + } + + @Override + public void clear() { + this.success = null; + } + + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + + public java.util.Iterator<DownloadInfo> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } + + public void addToSuccess(DownloadInfo elem) { + if (this.success == null) { + this.success = new ArrayList<DownloadInfo>(); + } + this.success.add(elem); + } + + public List<DownloadInfo> getSuccess() { + return this.success; + } + + public statusDownloads_result setSuccess(List<DownloadInfo> 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, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<DownloadInfo>) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); + + } + throw new IllegalStateException(); + } + + /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ + public boolean isSet(_Fields field) { + if (field == null) { + throw new IllegalArgumentException(); + } + + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof statusDownloads_result) + return this.equals((statusDownloads_result) that); + return false; + } + + public boolean equals(statusDownloads_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + + return list.hashCode(); + } + + @Override + public int compareTo(statusDownloads_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } + + 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("statusDownloads_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, 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 statusDownloads_resultStandardSchemeFactory implements SchemeFactory { + public statusDownloads_resultStandardScheme getScheme() { + return new statusDownloads_resultStandardScheme(); + } + } + + private static class statusDownloads_resultStandardScheme extends StandardScheme<statusDownloads_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, statusDownloads_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 ArrayList<DownloadInfo>(_list198.size); + DownloadInfo _elem199; + for (int _i200 = 0; _i200 < _list198.size; ++_i200) { + _elem199 = new DownloadInfo(); + _elem199.read(iprot); + struct.success.add(_elem199); + } + iprot.readListEnd(); + } + 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, statusDownloads_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 (DownloadInfo _iter201 : struct.success) { + _iter201.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class statusDownloads_resultTupleSchemeFactory implements SchemeFactory { + public statusDownloads_resultTupleScheme getScheme() { + return new statusDownloads_resultTupleScheme(); + } + } + + private static class statusDownloads_resultTupleScheme extends TupleScheme<statusDownloads_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, statusDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (DownloadInfo _iter202 : struct.success) { + _iter202.write(oprot); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, statusDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list203 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<DownloadInfo>(_list203.size); + DownloadInfo _elem204; + for (int _i205 = 0; _i205 < _list203.size; ++_i205) { + _elem204 = new DownloadInfo(); + _elem204.read(iprot); + struct.success.add(_elem204); + } + } + struct.setSuccessIsSet(true); + } + } + } + + } + + public static class getPackageData_args implements org.apache.thrift.TBase<getPackageData_args, getPackageData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageData_args"); + + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getPackageData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageData_argsTupleSchemeFactory()); + } + + public int pid; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(pid); + } + + @Override + public int describeContents() { + return 0; + } + + public getPackageData_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.pid = in.readInt(); + } + + public static final android.os.Parcelable.Creator<getPackageData_args> CREATOR = new android.os.Parcelable.Creator<getPackageData_args>() { + @Override + public getPackageData_args[] newArray(int size) { + return new getPackageData_args[size]; + } + + @Override + public getPackageData_args createFromParcel(android.os.Parcel in) { + return new getPackageData_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); + + 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: // PID + return PID; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageData_args.class, metaDataMap); + } + + public getPackageData_args() { + } + + public getPackageData_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageData_args(getPackageData_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } + + public getPackageData_args deepCopy() { + return new getPackageData_args(this); + } + + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } + + public int getPid() { + return this.pid; + } + + public getPackageData_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } + + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } + + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } + + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); + + } + 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 PID: + return isSetPid(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageData_args) + return this.equals((getPackageData_args) that); + return false; + } + + public boolean equals(getPackageData_args that) { + if (that == null) + return false; + + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); + + return list.hashCode(); + } + + @Override + public int compareTo(getPackageData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + 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("getPackageData_args("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 getPackageData_argsStandardSchemeFactory implements SchemeFactory { + public getPackageData_argsStandardScheme getScheme() { + return new getPackageData_argsStandardScheme(); + } + } + + private static class getPackageData_argsStandardScheme extends StandardScheme<getPackageData_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageData_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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, getPackageData_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getPackageData_argsTupleSchemeFactory implements SchemeFactory { + public getPackageData_argsTupleScheme getScheme() { + return new getPackageData_argsTupleScheme(); + } + } + + private static class getPackageData_argsTupleScheme extends TupleScheme<getPackageData_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - public List<Integer> recv_generateAndAddPackages() throws org.apache.thrift.TException - { - generateAndAddPackages_result result = new generateAndAddPackages_result(); - receiveBase(result, "generateAndAddPackages"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "generateAndAddPackages failed: unknown result"); } - public int addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException - { - send_addPackage(name, links, dest); - return recv_addPackage(); - } + public static class getPackageData_result implements org.apache.thrift.TBase<getPackageData_result, getPackageData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageData_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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short) 1); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getPackageData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageData_resultTupleSchemeFactory()); + } + + public PackageData success; // required + public PackageDoesNotExists e; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } + + @Override + public int describeContents() { + return 0; + } + + public getPackageData_result(android.os.Parcel in) { + this.success = in.readParcelable(getPackageData_result.class.getClassLoader()); + } + + public static final android.os.Parcelable.Creator<getPackageData_result> CREATOR = new android.os.Parcelable.Creator<getPackageData_result>() { + @Override + public getPackageData_result[] newArray(int size) { + return new getPackageData_result[size]; + } + + @Override + public getPackageData_result createFromParcel(android.os.Parcel in) { + return new getPackageData_result(in); + } + }; + + /** 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"), + E((short) 1, "e"); + + 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 0: // SUCCESS + return SUCCESS; + case 1: // E + return E; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class))); + tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageData_result.class, metaDataMap); + } + + public getPackageData_result() { + } - public void send_addPackage(String name, List<String> links, Destination dest) throws org.apache.thrift.TException - { - addPackage_args args = new addPackage_args(); - args.setName(name); - args.setLinks(links); - args.setDest(dest); - sendBase("addPackage", args); - } + public getPackageData_result( + PackageData success, + PackageDoesNotExists e) { + this(); + this.success = success; + this.e = e; + } - public int recv_addPackage() throws org.apache.thrift.TException - { - addPackage_result result = new addPackage_result(); - receiveBase(result, "addPackage"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "addPackage failed: unknown result"); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageData_result(getPackageData_result other) { + if (other.isSetSuccess()) { + this.success = new PackageData(other.success); + } + if (other.isSetE()) { + this.e = new PackageDoesNotExists(other.e); + } + } - public void addFiles(int pid, List<String> links) throws org.apache.thrift.TException - { - send_addFiles(pid, links); - recv_addFiles(); - } + public getPackageData_result deepCopy() { + return new getPackageData_result(this); + } - public void send_addFiles(int pid, List<String> links) throws org.apache.thrift.TException - { - addFiles_args args = new addFiles_args(); - args.setPid(pid); - args.setLinks(links); - sendBase("addFiles", args); - } + @Override + public void clear() { + this.success = null; + this.e = null; + } - public void recv_addFiles() throws org.apache.thrift.TException - { - addFiles_result result = new addFiles_result(); - receiveBase(result, "addFiles"); - return; - } + public PackageData getSuccess() { + return this.success; + } - public void uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException - { - send_uploadContainer(filename, data); - recv_uploadContainer(); - } + public getPackageData_result setSuccess(PackageData success) { + this.success = success; + return this; + } - public void send_uploadContainer(String filename, ByteBuffer data) throws org.apache.thrift.TException - { - uploadContainer_args args = new uploadContainer_args(); - args.setFilename(filename); - args.setData(data); - sendBase("uploadContainer", args); - } + public void unsetSuccess() { + this.success = null; + } - public void recv_uploadContainer() throws org.apache.thrift.TException - { - uploadContainer_result result = new uploadContainer_result(); - receiveBase(result, "uploadContainer"); - return; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public void deleteFiles(List<Integer> fids) throws org.apache.thrift.TException - { - send_deleteFiles(fids); - recv_deleteFiles(); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public void send_deleteFiles(List<Integer> fids) throws org.apache.thrift.TException - { - deleteFiles_args args = new deleteFiles_args(); - args.setFids(fids); - sendBase("deleteFiles", args); - } + public PackageDoesNotExists getE() { + return this.e; + } - public void recv_deleteFiles() throws org.apache.thrift.TException - { - deleteFiles_result result = new deleteFiles_result(); - receiveBase(result, "deleteFiles"); - return; - } + public getPackageData_result setE(PackageDoesNotExists e) { + this.e = e; + return this; + } - public void deletePackages(List<Integer> pids) throws org.apache.thrift.TException - { - send_deletePackages(pids); - recv_deletePackages(); - } + public void unsetE() { + this.e = null; + } - public void send_deletePackages(List<Integer> pids) throws org.apache.thrift.TException - { - deletePackages_args args = new deletePackages_args(); - args.setPids(pids); - sendBase("deletePackages", args); - } + /** Returns true if field e is set (has been assigned a value) and false otherwise */ + public boolean isSetE() { + return this.e != null; + } - public void recv_deletePackages() throws org.apache.thrift.TException - { - deletePackages_result result = new deletePackages_result(); - receiveBase(result, "deletePackages"); - return; - } + public void setEIsSet(boolean value) { + if (!value) { + this.e = null; + } + } - public void pushToQueue(int pid) throws org.apache.thrift.TException - { - send_pushToQueue(pid); - recv_pushToQueue(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((PackageData) value); + } + break; - public void send_pushToQueue(int pid) throws org.apache.thrift.TException - { - pushToQueue_args args = new pushToQueue_args(); - args.setPid(pid); - sendBase("pushToQueue", args); - } + case E: + if (value == null) { + unsetE(); + } else { + setE((PackageDoesNotExists) value); + } + break; - public void recv_pushToQueue() throws org.apache.thrift.TException - { - pushToQueue_result result = new pushToQueue_result(); - receiveBase(result, "pushToQueue"); - return; - } + } + } - public void pullFromQueue(int pid) throws org.apache.thrift.TException - { - send_pullFromQueue(pid); - recv_pullFromQueue(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public void send_pullFromQueue(int pid) throws org.apache.thrift.TException - { - pullFromQueue_args args = new pullFromQueue_args(); - args.setPid(pid); - sendBase("pullFromQueue", args); - } + case E: + return getE(); - public void recv_pullFromQueue() throws org.apache.thrift.TException - { - pullFromQueue_result result = new pullFromQueue_result(); - receiveBase(result, "pullFromQueue"); - return; - } + } + throw new IllegalStateException(); + } - public void restartPackage(int pid) throws org.apache.thrift.TException - { - send_restartPackage(pid); - recv_restartPackage(); - } + /** 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(); + } - public void send_restartPackage(int pid) throws org.apache.thrift.TException - { - restartPackage_args args = new restartPackage_args(); - args.setPid(pid); - sendBase("restartPackage", args); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + case E: + return isSetE(); + } + throw new IllegalStateException(); + } - public void recv_restartPackage() throws org.apache.thrift.TException - { - restartPackage_result result = new restartPackage_result(); - receiveBase(result, "restartPackage"); - return; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageData_result) + return this.equals((getPackageData_result) that); + return false; + } - public void restartFile(int fid) throws org.apache.thrift.TException - { - send_restartFile(fid); - recv_restartFile(); - } + public boolean equals(getPackageData_result that) { + if (that == null) + return false; - public void send_restartFile(int fid) throws org.apache.thrift.TException - { - restartFile_args args = new restartFile_args(); - args.setFid(fid); - sendBase("restartFile", args); - } + 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; + } - public void recv_restartFile() throws org.apache.thrift.TException - { - restartFile_result result = new restartFile_result(); - receiveBase(result, "restartFile"); - return; - } + boolean this_present_e = true && this.isSetE(); + boolean that_present_e = true && that.isSetE(); + if (this_present_e || that_present_e) { + if (!(this_present_e && that_present_e)) + return false; + if (!this.e.equals(that.e)) + return false; + } - public void recheckPackage(int pid) throws org.apache.thrift.TException - { - send_recheckPackage(pid); - recv_recheckPackage(); - } + return true; + } - public void send_recheckPackage(int pid) throws org.apache.thrift.TException - { - recheckPackage_args args = new recheckPackage_args(); - args.setPid(pid); - sendBase("recheckPackage", args); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void recv_recheckPackage() throws org.apache.thrift.TException - { - recheckPackage_result result = new recheckPackage_result(); - receiveBase(result, "recheckPackage"); - return; - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public void stopAllDownloads() throws org.apache.thrift.TException - { - send_stopAllDownloads(); - recv_stopAllDownloads(); - } + boolean present_e = true && (isSetE()); + list.add(present_e); + if (present_e) + list.add(e); - public void send_stopAllDownloads() throws org.apache.thrift.TException - { - stopAllDownloads_args args = new stopAllDownloads_args(); - sendBase("stopAllDownloads", args); - } + return list.hashCode(); + } - public void recv_stopAllDownloads() throws org.apache.thrift.TException - { - stopAllDownloads_result result = new stopAllDownloads_result(); - receiveBase(result, "stopAllDownloads"); - return; - } + @Override + public int compareTo(getPackageData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void stopDownloads(List<Integer> fids) throws org.apache.thrift.TException - { - send_stopDownloads(fids); - recv_stopDownloads(); - } + int lastComparison = 0; - public void send_stopDownloads(List<Integer> fids) throws org.apache.thrift.TException - { - stopDownloads_args args = new stopDownloads_args(); - args.setFids(fids); - sendBase("stopDownloads", args); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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 = Boolean.valueOf(isSetE()).compareTo(other.isSetE()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetE()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, other.e); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void recv_stopDownloads() throws org.apache.thrift.TException - { - stopDownloads_result result = new stopDownloads_result(); - receiveBase(result, "stopDownloads"); - return; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setPackageName(int pid, String name) throws org.apache.thrift.TException - { - send_setPackageName(pid, name); - recv_setPackageName(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void send_setPackageName(int pid, String name) throws org.apache.thrift.TException - { - setPackageName_args args = new setPackageName_args(); - args.setPid(pid); - args.setName(name); - sendBase("setPackageName", args); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void recv_setPackageName() throws org.apache.thrift.TException - { - setPackageName_result result = new setPackageName_result(); - receiveBase(result, "setPackageName"); - return; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getPackageData_result("); + boolean first = true; - public void movePackage(Destination destination, int pid) throws org.apache.thrift.TException - { - send_movePackage(destination, pid); - recv_movePackage(); - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("e:"); + if (this.e == null) { + sb.append("null"); + } else { + sb.append(this.e); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public void send_movePackage(Destination destination, int pid) throws org.apache.thrift.TException - { - movePackage_args args = new movePackage_args(); - args.setDestination(destination); - args.setPid(pid); - sendBase("movePackage", args); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } - public void recv_movePackage() throws org.apache.thrift.TException - { - movePackage_result result = new movePackage_result(); - receiveBase(result, "movePackage"); - return; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException - { - send_moveFiles(fids, pid); - recv_moveFiles(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void send_moveFiles(List<Integer> fids, int pid) throws org.apache.thrift.TException - { - moveFiles_args args = new moveFiles_args(); - args.setFids(fids); - args.setPid(pid); - sendBase("moveFiles", args); - } + private static class getPackageData_resultStandardSchemeFactory implements SchemeFactory { + public getPackageData_resultStandardScheme getScheme() { + return new getPackageData_resultStandardScheme(); + } + } - public void recv_moveFiles() throws org.apache.thrift.TException - { - moveFiles_result result = new moveFiles_result(); - receiveBase(result, "moveFiles"); - return; - } + private static class getPackageData_resultStandardScheme extends StandardScheme<getPackageData_result> { - public void orderPackage(int pid, short position) throws org.apache.thrift.TException - { - send_orderPackage(pid, position); - recv_orderPackage(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageData_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 PackageData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // E + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(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(); - public void send_orderPackage(int pid, short position) throws org.apache.thrift.TException - { - orderPackage_args args = new orderPackage_args(); - args.setPid(pid); - args.setPosition(position); - sendBase("orderPackage", args); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public void recv_orderPackage() throws org.apache.thrift.TException - { - orderPackage_result result = new orderPackage_result(); - receiveBase(result, "orderPackage"); - return; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getPackageData_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void orderFile(int fid, short position) throws org.apache.thrift.TException - { - send_orderFile(fid, position); - recv_orderFile(); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.e != null) { + oprot.writeFieldBegin(E_FIELD_DESC); + struct.e.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void send_orderFile(int fid, short position) throws org.apache.thrift.TException - { - orderFile_args args = new orderFile_args(); - args.setFid(fid); - args.setPosition(position); - sendBase("orderFile", args); - } + } - public void recv_orderFile() throws org.apache.thrift.TException - { - orderFile_result result = new orderFile_result(); - receiveBase(result, "orderFile"); - return; - } + private static class getPackageData_resultTupleSchemeFactory implements SchemeFactory { + public getPackageData_resultTupleScheme getScheme() { + return new getPackageData_resultTupleScheme(); + } + } - public void setPackageData(int pid, Map<String,String> data) throws PackageDoesNotExists, org.apache.thrift.TException - { - send_setPackageData(pid, data); - recv_setPackageData(); - } + private static class getPackageData_resultTupleScheme extends TupleScheme<getPackageData_result> { - public void send_setPackageData(int pid, Map<String,String> data) throws org.apache.thrift.TException - { - setPackageData_args args = new setPackageData_args(); - args.setPid(pid); - args.setData(data); - sendBase("setPackageData", args); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetE()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetE()) { + struct.e.write(oprot); + } + } - public void recv_setPackageData() throws PackageDoesNotExists, org.apache.thrift.TException - { - setPackageData_result result = new setPackageData_result(); - receiveBase(result, "setPackageData"); - if (result.e != null) { - throw result.e; - } - return; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = new PackageData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(true); + } + } + } - public List<Integer> deleteFinished() throws org.apache.thrift.TException - { - send_deleteFinished(); - return recv_deleteFinished(); } - public void send_deleteFinished() throws org.apache.thrift.TException - { - deleteFinished_args args = new deleteFinished_args(); - sendBase("deleteFinished", args); - } + public static class getPackageInfo_args implements org.apache.thrift.TBase<getPackageInfo_args, getPackageInfo_args._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageInfo_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageInfo_args"); - public List<Integer> recv_deleteFinished() throws org.apache.thrift.TException - { - deleteFinished_result result = new deleteFinished_result(); - receiveBase(result, "deleteFinished"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "deleteFinished failed: unknown result"); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - public void restartFailed() throws org.apache.thrift.TException - { - send_restartFailed(); - recv_restartFailed(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void send_restartFailed() throws org.apache.thrift.TException - { - restartFailed_args args = new restartFailed_args(); - sendBase("restartFailed", args); - } + static { + schemes.put(StandardScheme.class, new getPackageInfo_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageInfo_argsTupleSchemeFactory()); + } - public void recv_restartFailed() throws org.apache.thrift.TException - { - restartFailed_result result = new restartFailed_result(); - receiveBase(result, "restartFailed"); - return; - } + public int pid; // required - public boolean isCaptchaWaiting() throws org.apache.thrift.TException - { - send_isCaptchaWaiting(); - return recv_isCaptchaWaiting(); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public void send_isCaptchaWaiting() throws org.apache.thrift.TException - { - isCaptchaWaiting_args args = new isCaptchaWaiting_args(); - sendBase("isCaptchaWaiting", args); - } + out.writeInt(pid); + } - public boolean recv_isCaptchaWaiting() throws org.apache.thrift.TException - { - isCaptchaWaiting_result result = new isCaptchaWaiting_result(); - receiveBase(result, "isCaptchaWaiting"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "isCaptchaWaiting failed: unknown result"); - } + @Override + public int describeContents() { + return 0; + } - public CaptchaTask getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException - { - send_getCaptchaTask(exclusive); - return recv_getCaptchaTask(); - } + public getPackageInfo_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void send_getCaptchaTask(boolean exclusive) throws org.apache.thrift.TException - { - getCaptchaTask_args args = new getCaptchaTask_args(); - args.setExclusive(exclusive); - sendBase("getCaptchaTask", args); - } + this.pid = in.readInt(); + } - public CaptchaTask recv_getCaptchaTask() throws org.apache.thrift.TException - { - getCaptchaTask_result result = new getCaptchaTask_result(); - receiveBase(result, "getCaptchaTask"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCaptchaTask failed: unknown result"); - } + public static final android.os.Parcelable.Creator<getPackageInfo_args> CREATOR = new android.os.Parcelable.Creator<getPackageInfo_args>() { + @Override + public getPackageInfo_args[] newArray(int size) { + return new getPackageInfo_args[size]; + } - public String getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException - { - send_getCaptchaTaskStatus(tid); - return recv_getCaptchaTaskStatus(); - } + @Override + public getPackageInfo_args createFromParcel(android.os.Parcel in) { + return new getPackageInfo_args(in); + } + }; - public void send_getCaptchaTaskStatus(int tid) throws org.apache.thrift.TException - { - getCaptchaTaskStatus_args args = new getCaptchaTaskStatus_args(); - args.setTid(tid); - sendBase("getCaptchaTaskStatus", args); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - public String recv_getCaptchaTaskStatus() throws org.apache.thrift.TException - { - getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); - receiveBase(result, "getCaptchaTaskStatus"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getCaptchaTaskStatus failed: unknown result"); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void setCaptchaResult(int tid, String result) throws org.apache.thrift.TException - { - send_setCaptchaResult(tid, result); - recv_setCaptchaResult(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void send_setCaptchaResult(int tid, String result) throws org.apache.thrift.TException - { - setCaptchaResult_args args = new setCaptchaResult_args(); - args.setTid(tid); - args.setResult(result); - sendBase("setCaptchaResult", args); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - public void recv_setCaptchaResult() throws org.apache.thrift.TException - { - setCaptchaResult_result result = new setCaptchaResult_result(); - receiveBase(result, "setCaptchaResult"); - return; - } + /** + * 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; + } - public List<EventInfo> getEvents(String uuid) throws org.apache.thrift.TException - { - send_getEvents(uuid); - return recv_getEvents(); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void send_getEvents(String uuid) throws org.apache.thrift.TException - { - getEvents_args args = new getEvents_args(); - args.setUuid(uuid); - sendBase("getEvents", args); - } + private final short _thriftId; + private final String _fieldName; - public List<EventInfo> recv_getEvents() throws org.apache.thrift.TException - { - getEvents_result result = new getEvents_result(); - receiveBase(result, "getEvents"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getEvents failed: unknown result"); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public List<AccountInfo> getAccounts(boolean refresh) throws org.apache.thrift.TException - { - send_getAccounts(refresh); - return recv_getAccounts(); - } + public short getThriftFieldId() { + return _thriftId; + } - public void send_getAccounts(boolean refresh) throws org.apache.thrift.TException - { - getAccounts_args args = new getAccounts_args(); - args.setRefresh(refresh); - sendBase("getAccounts", args); - } + public String getFieldName() { + return _fieldName; + } + } - public List<AccountInfo> recv_getAccounts() throws org.apache.thrift.TException - { - getAccounts_result result = new getAccounts_result(); - receiveBase(result, "getAccounts"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAccounts failed: unknown result"); - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public List<String> getAccountTypes() throws org.apache.thrift.TException - { - send_getAccountTypes(); - return recv_getAccountTypes(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageInfo_args.class, metaDataMap); + } + + public getPackageInfo_args() { + } + + public getPackageInfo_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageInfo_args(getPackageInfo_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } + + public getPackageInfo_args deepCopy() { + return new getPackageInfo_args(this); + } + + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } + + public int getPid() { + return this.pid; + } + + public getPackageInfo_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } + + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } + + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } + + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); + + } + 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 PID: + return isSetPid(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageInfo_args) + return this.equals((getPackageInfo_args) that); + return false; + } + + public boolean equals(getPackageInfo_args that) { + if (that == null) + return false; + + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); + + return list.hashCode(); + } + + @Override + public int compareTo(getPackageInfo_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + 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("getPackageInfo_args("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 getPackageInfo_argsStandardSchemeFactory implements SchemeFactory { + public getPackageInfo_argsStandardScheme getScheme() { + return new getPackageInfo_argsStandardScheme(); + } + } + + private static class getPackageInfo_argsStandardScheme extends StandardScheme<getPackageInfo_args> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageInfo_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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, getPackageInfo_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class getPackageInfo_argsTupleSchemeFactory implements SchemeFactory { + public getPackageInfo_argsTupleScheme getScheme() { + return new getPackageInfo_argsTupleScheme(); + } + } - public void send_getAccountTypes() throws org.apache.thrift.TException - { - getAccountTypes_args args = new getAccountTypes_args(); - sendBase("getAccountTypes", args); - } + private static class getPackageInfo_argsTupleScheme extends TupleScheme<getPackageInfo_args> { - public List<String> recv_getAccountTypes() throws org.apache.thrift.TException - { - getAccountTypes_result result = new getAccountTypes_result(); - receiveBase(result, "getAccountTypes"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAccountTypes failed: unknown result"); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - public void updateAccount(String plugin, String account, String password, Map<String,String> options) throws org.apache.thrift.TException - { - send_updateAccount(plugin, account, password, options); - recv_updateAccount(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - public void send_updateAccount(String plugin, String account, String password, Map<String,String> options) throws org.apache.thrift.TException - { - updateAccount_args args = new updateAccount_args(); - args.setPlugin(plugin); - args.setAccount(account); - args.setPassword(password); - args.setOptions(options); - sendBase("updateAccount", args); } - public void recv_updateAccount() throws org.apache.thrift.TException - { - updateAccount_result result = new updateAccount_result(); - receiveBase(result, "updateAccount"); - return; - } + public static class getPackageInfo_result implements org.apache.thrift.TBase<getPackageInfo_result, getPackageInfo_result._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageInfo_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageInfo_result"); - public void removeAccount(String plugin, String account) throws org.apache.thrift.TException - { - send_removeAccount(plugin, account); - recv_removeAccount(); - } + 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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short) 1); - public void send_removeAccount(String plugin, String account) throws org.apache.thrift.TException - { - removeAccount_args args = new removeAccount_args(); - args.setPlugin(plugin); - args.setAccount(account); - sendBase("removeAccount", args); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void recv_removeAccount() throws org.apache.thrift.TException - { - removeAccount_result result = new removeAccount_result(); - receiveBase(result, "removeAccount"); - return; - } + static { + schemes.put(StandardScheme.class, new getPackageInfo_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageInfo_resultTupleSchemeFactory()); + } - public boolean login(String username, String password) throws org.apache.thrift.TException - { - send_login(username, password); - return recv_login(); - } + public PackageData success; // required + public PackageDoesNotExists e; // required - public void send_login(String username, String password) throws org.apache.thrift.TException - { - login_args args = new login_args(); - args.setUsername(username); - args.setPassword(password); - sendBase("login", args); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } - public boolean recv_login() throws org.apache.thrift.TException - { - login_result result = new login_result(); - receiveBase(result, "login"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "login failed: unknown result"); - } + @Override + public int describeContents() { + return 0; + } - public UserData getUserData(String username, String password) throws org.apache.thrift.TException - { - send_getUserData(username, password); - return recv_getUserData(); - } + public getPackageInfo_result(android.os.Parcel in) { + this.success = in.readParcelable(getPackageInfo_result.class.getClassLoader()); + } - public void send_getUserData(String username, String password) throws org.apache.thrift.TException - { - getUserData_args args = new getUserData_args(); - args.setUsername(username); - args.setPassword(password); - sendBase("getUserData", args); - } + public static final android.os.Parcelable.Creator<getPackageInfo_result> CREATOR = new android.os.Parcelable.Creator<getPackageInfo_result>() { + @Override + public getPackageInfo_result[] newArray(int size) { + return new getPackageInfo_result[size]; + } - public UserData recv_getUserData() throws org.apache.thrift.TException - { - getUserData_result result = new getUserData_result(); - receiveBase(result, "getUserData"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getUserData failed: unknown result"); - } + @Override + public getPackageInfo_result createFromParcel(android.os.Parcel in) { + return new getPackageInfo_result(in); + } + }; - public Map<String,UserData> getAllUserData() throws org.apache.thrift.TException - { - send_getAllUserData(); - return recv_getAllUserData(); - } + /** 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"), + E((short) 1, "e"); - public void send_getAllUserData() throws org.apache.thrift.TException - { - getAllUserData_args args = new getAllUserData_args(); - sendBase("getAllUserData", args); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Map<String,UserData> recv_getAllUserData() throws org.apache.thrift.TException - { - getAllUserData_result result = new getAllUserData_result(); - receiveBase(result, "getAllUserData"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllUserData failed: unknown result"); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public Map<String,Map<String,String>> getServices() throws org.apache.thrift.TException - { - send_getServices(); - return recv_getServices(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // E + return E; + default: + return null; + } + } - public void send_getServices() throws org.apache.thrift.TException - { - getServices_args args = new getServices_args(); - sendBase("getServices", args); - } + /** + * 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; + } - public Map<String,Map<String,String>> recv_getServices() throws org.apache.thrift.TException - { - getServices_result result = new getServices_result(); - receiveBase(result, "getServices"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getServices failed: unknown result"); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public boolean hasService(String plugin, String func) throws org.apache.thrift.TException - { - send_hasService(plugin, func); - return recv_hasService(); - } + private final short _thriftId; + private final String _fieldName; - public void send_hasService(String plugin, String func) throws org.apache.thrift.TException - { - hasService_args args = new hasService_args(); - args.setPlugin(plugin); - args.setFunc(func); - sendBase("hasService", args); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public boolean recv_hasService() throws org.apache.thrift.TException - { - hasService_result result = new hasService_result(); - receiveBase(result, "hasService"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "hasService failed: unknown result"); - } + public short getThriftFieldId() { + return _thriftId; + } - public String call(ServiceCall info) throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException - { - send_call(info); - return recv_call(); - } + public String getFieldName() { + return _fieldName; + } + } - public void send_call(ServiceCall info) throws org.apache.thrift.TException - { - call_args args = new call_args(); - args.setInfo(info); - sendBase("call", args); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public String recv_call() throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException - { - call_result result = new call_result(); - receiveBase(result, "call"); - if (result.isSetSuccess()) { - return result.success; - } - if (result.ex != null) { - throw result.ex; - } - if (result.e != null) { - throw result.e; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "call failed: unknown result"); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class))); + tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageInfo_result.class, metaDataMap); + } - public Map<String,Map<String,String>> getAllInfo() throws org.apache.thrift.TException - { - send_getAllInfo(); - return recv_getAllInfo(); - } + public getPackageInfo_result() { + } - public void send_getAllInfo() throws org.apache.thrift.TException - { - getAllInfo_args args = new getAllInfo_args(); - sendBase("getAllInfo", args); - } + public getPackageInfo_result( + PackageData success, + PackageDoesNotExists e) { + this(); + this.success = success; + this.e = e; + } - public Map<String,Map<String,String>> recv_getAllInfo() throws org.apache.thrift.TException - { - getAllInfo_result result = new getAllInfo_result(); - receiveBase(result, "getAllInfo"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllInfo failed: unknown result"); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageInfo_result(getPackageInfo_result other) { + if (other.isSetSuccess()) { + this.success = new PackageData(other.success); + } + if (other.isSetE()) { + this.e = new PackageDoesNotExists(other.e); + } + } - public Map<String,String> getInfoByPlugin(String plugin) throws org.apache.thrift.TException - { - send_getInfoByPlugin(plugin); - return recv_getInfoByPlugin(); - } + public getPackageInfo_result deepCopy() { + return new getPackageInfo_result(this); + } - public void send_getInfoByPlugin(String plugin) throws org.apache.thrift.TException - { - getInfoByPlugin_args args = new getInfoByPlugin_args(); - args.setPlugin(plugin); - sendBase("getInfoByPlugin", args); - } + @Override + public void clear() { + this.success = null; + this.e = null; + } - public Map<String,String> recv_getInfoByPlugin() throws org.apache.thrift.TException - { - getInfoByPlugin_result result = new getInfoByPlugin_result(); - receiveBase(result, "getInfoByPlugin"); - if (result.isSetSuccess()) { - return result.success; - } - throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getInfoByPlugin failed: unknown result"); - } + public PackageData getSuccess() { + return this.success; + } - } - 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 getPackageInfo_result setSuccess(PackageData success) { + this.success = success; + return this; + } - 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 unsetSuccess() { + this.success = null; + } - public void getConfigValue(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback<getConfigValue_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getConfigValue_call method_call = new getConfigValue_call(category, option, section, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public static class getConfigValue_call extends org.apache.thrift.async.TAsyncMethodCall { - private String category; - private String option; - private String section; - public getConfigValue_call(String category, String option, String section, org.apache.thrift.async.AsyncMethodCallback<getConfigValue_call> 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.category = category; - this.option = option; - this.section = section; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getConfigValue", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getConfigValue_args args = new getConfigValue_args(); - args.setCategory(category); - args.setOption(option); - args.setSection(section); - args.write(prot); - prot.writeMessageEnd(); - } - - public String getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getConfigValue(); - } - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public void setConfigValue(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback<setConfigValue_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - setConfigValue_call method_call = new setConfigValue_call(category, option, value, section, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public PackageDoesNotExists getE() { + return this.e; + } - public static class setConfigValue_call extends org.apache.thrift.async.TAsyncMethodCall { - private String category; - private String option; - private String value; - private String section; - public setConfigValue_call(String category, String option, String value, String section, org.apache.thrift.async.AsyncMethodCallback<setConfigValue_call> 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.category = category; - this.option = option; - this.value = value; - this.section = section; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setConfigValue", org.apache.thrift.protocol.TMessageType.CALL, 0)); - setConfigValue_args args = new setConfigValue_args(); - args.setCategory(category); - args.setOption(option); - args.setValue(value); - args.setSection(section); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_setConfigValue(); - } - } + public getPackageInfo_result setE(PackageDoesNotExists e) { + this.e = e; + return this; + } - public void getConfig(org.apache.thrift.async.AsyncMethodCallback<getConfig_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getConfig_call method_call = new getConfig_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void unsetE() { + this.e = null; + } - public static class getConfig_call extends org.apache.thrift.async.TAsyncMethodCall { - public getConfig_call(org.apache.thrift.async.AsyncMethodCallback<getConfig_call> 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("getConfig", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getConfig_args args = new getConfig_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,ConfigSection> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getConfig(); - } - } + /** Returns true if field e is set (has been assigned a value) and false otherwise */ + public boolean isSetE() { + return this.e != null; + } - public void getPluginConfig(org.apache.thrift.async.AsyncMethodCallback<getPluginConfig_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getPluginConfig_call method_call = new getPluginConfig_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void setEIsSet(boolean value) { + if (!value) { + this.e = null; + } + } - public static class getPluginConfig_call extends org.apache.thrift.async.TAsyncMethodCall { - public getPluginConfig_call(org.apache.thrift.async.AsyncMethodCallback<getPluginConfig_call> 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("getPluginConfig", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getPluginConfig_args args = new getPluginConfig_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,ConfigSection> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getPluginConfig(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((PackageData) value); + } + break; - public void pauseServer(org.apache.thrift.async.AsyncMethodCallback<pauseServer_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - pauseServer_call method_call = new pauseServer_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + case E: + if (value == null) { + unsetE(); + } else { + setE((PackageDoesNotExists) value); + } + break; - public static class pauseServer_call extends org.apache.thrift.async.TAsyncMethodCall { - public pauseServer_call(org.apache.thrift.async.AsyncMethodCallback<pauseServer_call> 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("pauseServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); - pauseServer_args args = new pauseServer_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_pauseServer(); - } - } + } + } - public void unpauseServer(org.apache.thrift.async.AsyncMethodCallback<unpauseServer_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - unpauseServer_call method_call = new unpauseServer_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public static class unpauseServer_call extends org.apache.thrift.async.TAsyncMethodCall { - public unpauseServer_call(org.apache.thrift.async.AsyncMethodCallback<unpauseServer_call> 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("unpauseServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); - unpauseServer_args args = new unpauseServer_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_unpauseServer(); - } - } + case E: + return getE(); - public void togglePause(org.apache.thrift.async.AsyncMethodCallback<togglePause_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - togglePause_call method_call = new togglePause_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + } + throw new IllegalStateException(); + } - public static class togglePause_call extends org.apache.thrift.async.TAsyncMethodCall { - public togglePause_call(org.apache.thrift.async.AsyncMethodCallback<togglePause_call> 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("togglePause", org.apache.thrift.protocol.TMessageType.CALL, 0)); - togglePause_args args = new togglePause_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_togglePause(); - } - } + /** 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(); + } - public void statusServer(org.apache.thrift.async.AsyncMethodCallback<statusServer_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - statusServer_call method_call = new statusServer_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + case E: + return isSetE(); + } + throw new IllegalStateException(); + } - public static class statusServer_call extends org.apache.thrift.async.TAsyncMethodCall { - public statusServer_call(org.apache.thrift.async.AsyncMethodCallback<statusServer_call> 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("statusServer", org.apache.thrift.protocol.TMessageType.CALL, 0)); - statusServer_args args = new statusServer_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public ServerStatus getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_statusServer(); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageInfo_result) + return this.equals((getPackageInfo_result) that); + return false; + } - public void freeSpace(org.apache.thrift.async.AsyncMethodCallback<freeSpace_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - freeSpace_call method_call = new freeSpace_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public boolean equals(getPackageInfo_result that) { + if (that == null) + return false; - public static class freeSpace_call extends org.apache.thrift.async.TAsyncMethodCall { - public freeSpace_call(org.apache.thrift.async.AsyncMethodCallback<freeSpace_call> 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("freeSpace", org.apache.thrift.protocol.TMessageType.CALL, 0)); - freeSpace_args args = new freeSpace_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public long getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_freeSpace(); - } - } + 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; + } - public void getServerVersion(org.apache.thrift.async.AsyncMethodCallback<getServerVersion_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getServerVersion_call method_call = new getServerVersion_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + boolean this_present_e = true && this.isSetE(); + boolean that_present_e = true && that.isSetE(); + if (this_present_e || that_present_e) { + if (!(this_present_e && that_present_e)) + return false; + if (!this.e.equals(that.e)) + return false; + } - public static class getServerVersion_call extends org.apache.thrift.async.TAsyncMethodCall { - public getServerVersion_call(org.apache.thrift.async.AsyncMethodCallback<getServerVersion_call> 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("getServerVersion", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getServerVersion_args args = new getServerVersion_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public String getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getServerVersion(); - } - } + return true; + } - public void kill(org.apache.thrift.async.AsyncMethodCallback<kill_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - kill_call method_call = new kill_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public static class kill_call extends org.apache.thrift.async.TAsyncMethodCall { - public kill_call(org.apache.thrift.async.AsyncMethodCallback<kill_call> 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("kill", org.apache.thrift.protocol.TMessageType.CALL, 0)); - kill_args args = new kill_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_kill(); - } - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public void restart(org.apache.thrift.async.AsyncMethodCallback<restart_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - restart_call method_call = new restart_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + boolean present_e = true && (isSetE()); + list.add(present_e); + if (present_e) + list.add(e); - public static class restart_call extends org.apache.thrift.async.TAsyncMethodCall { - public restart_call(org.apache.thrift.async.AsyncMethodCallback<restart_call> 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("restart", org.apache.thrift.protocol.TMessageType.CALL, 0)); - restart_args args = new restart_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_restart(); - } - } + return list.hashCode(); + } - public void getLog(int offset, org.apache.thrift.async.AsyncMethodCallback<getLog_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getLog_call method_call = new getLog_call(offset, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public int compareTo(getPackageInfo_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public static class getLog_call extends org.apache.thrift.async.TAsyncMethodCall { - private int offset; - public getLog_call(int offset, org.apache.thrift.async.AsyncMethodCallback<getLog_call> 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.offset = offset; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getLog", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getLog_args args = new getLog_args(); - args.setOffset(offset); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<String> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getLog(); - } - } + int lastComparison = 0; - public void isTimeDownload(org.apache.thrift.async.AsyncMethodCallback<isTimeDownload_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - isTimeDownload_call method_call = new isTimeDownload_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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 = Boolean.valueOf(isSetE()).compareTo(other.isSetE()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetE()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, other.e); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public static class isTimeDownload_call extends org.apache.thrift.async.TAsyncMethodCall { - public isTimeDownload_call(org.apache.thrift.async.AsyncMethodCallback<isTimeDownload_call> 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("isTimeDownload", org.apache.thrift.protocol.TMessageType.CALL, 0)); - isTimeDownload_args args = new isTimeDownload_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_isTimeDownload(); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void isTimeReconnect(org.apache.thrift.async.AsyncMethodCallback<isTimeReconnect_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - isTimeReconnect_call method_call = new isTimeReconnect_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public static class isTimeReconnect_call extends org.apache.thrift.async.TAsyncMethodCall { - public isTimeReconnect_call(org.apache.thrift.async.AsyncMethodCallback<isTimeReconnect_call> 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("isTimeReconnect", org.apache.thrift.protocol.TMessageType.CALL, 0)); - isTimeReconnect_args args = new isTimeReconnect_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_isTimeReconnect(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void toggleReconnect(org.apache.thrift.async.AsyncMethodCallback<toggleReconnect_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - toggleReconnect_call method_call = new toggleReconnect_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getPackageInfo_result("); + boolean first = true; - public static class toggleReconnect_call extends org.apache.thrift.async.TAsyncMethodCall { - public toggleReconnect_call(org.apache.thrift.async.AsyncMethodCallback<toggleReconnect_call> 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("toggleReconnect", org.apache.thrift.protocol.TMessageType.CALL, 0)); - toggleReconnect_args args = new toggleReconnect_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_toggleReconnect(); - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("e:"); + if (this.e == null) { + sb.append("null"); + } else { + sb.append(this.e); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public void generatePackages(List<String> links, org.apache.thrift.async.AsyncMethodCallback<generatePackages_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - generatePackages_call method_call = new generatePackages_call(links, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } - public static class generatePackages_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<String> links; - public generatePackages_call(List<String> links, org.apache.thrift.async.AsyncMethodCallback<generatePackages_call> 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.links = links; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("generatePackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); - generatePackages_args args = new generatePackages_args(); - args.setLinks(links); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,List<String>> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_generatePackages(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void checkURLs(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<checkURLs_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - checkURLs_call method_call = new checkURLs_call(urls, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public static class checkURLs_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<String> urls; - public checkURLs_call(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<checkURLs_call> 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.urls = urls; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkURLs", org.apache.thrift.protocol.TMessageType.CALL, 0)); - checkURLs_args args = new checkURLs_args(); - args.setUrls(urls); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,List<String>> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_checkURLs(); - } - } + private static class getPackageInfo_resultStandardSchemeFactory implements SchemeFactory { + public getPackageInfo_resultStandardScheme getScheme() { + return new getPackageInfo_resultStandardScheme(); + } + } - public void parseURLs(String html, String url, org.apache.thrift.async.AsyncMethodCallback<parseURLs_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - parseURLs_call method_call = new parseURLs_call(html, url, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static class getPackageInfo_resultStandardScheme extends StandardScheme<getPackageInfo_result> { - public static class parseURLs_call extends org.apache.thrift.async.TAsyncMethodCall { - private String html; - private String url; - public parseURLs_call(String html, String url, org.apache.thrift.async.AsyncMethodCallback<parseURLs_call> 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.html = html; - this.url = url; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("parseURLs", org.apache.thrift.protocol.TMessageType.CALL, 0)); - parseURLs_args args = new parseURLs_args(); - args.setHtml(html); - args.setUrl(url); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,List<String>> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_parseURLs(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageInfo_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 PackageData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // E + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(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(); - public void checkOnlineStatus(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<checkOnlineStatus_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - checkOnlineStatus_call method_call = new checkOnlineStatus_call(urls, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public static class checkOnlineStatus_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<String> urls; - public checkOnlineStatus_call(List<String> urls, org.apache.thrift.async.AsyncMethodCallback<checkOnlineStatus_call> 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.urls = urls; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkOnlineStatus", org.apache.thrift.protocol.TMessageType.CALL, 0)); - checkOnlineStatus_args args = new checkOnlineStatus_args(); - args.setUrls(urls); - args.write(prot); - prot.writeMessageEnd(); - } - - public OnlineCheck getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_checkOnlineStatus(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getPackageInfo_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void checkOnlineStatusContainer(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<checkOnlineStatusContainer_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - checkOnlineStatusContainer_call method_call = new checkOnlineStatusContainer_call(urls, filename, data, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.e != null) { + oprot.writeFieldBegin(E_FIELD_DESC); + struct.e.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public static class checkOnlineStatusContainer_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<String> urls; - private String filename; - private ByteBuffer data; - public checkOnlineStatusContainer_call(List<String> urls, String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<checkOnlineStatusContainer_call> 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.urls = urls; - this.filename = filename; - this.data = data; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("checkOnlineStatusContainer", org.apache.thrift.protocol.TMessageType.CALL, 0)); - checkOnlineStatusContainer_args args = new checkOnlineStatusContainer_args(); - args.setUrls(urls); - args.setFilename(filename); - args.setData(data); - args.write(prot); - prot.writeMessageEnd(); - } - - public OnlineCheck getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_checkOnlineStatusContainer(); - } - } + } - public void pollResults(int rid, org.apache.thrift.async.AsyncMethodCallback<pollResults_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - pollResults_call method_call = new pollResults_call(rid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static class getPackageInfo_resultTupleSchemeFactory implements SchemeFactory { + public getPackageInfo_resultTupleScheme getScheme() { + return new getPackageInfo_resultTupleScheme(); + } + } - public static class pollResults_call extends org.apache.thrift.async.TAsyncMethodCall { - private int rid; - public pollResults_call(int rid, org.apache.thrift.async.AsyncMethodCallback<pollResults_call> 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.rid = rid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pollResults", org.apache.thrift.protocol.TMessageType.CALL, 0)); - pollResults_args args = new pollResults_args(); - args.setRid(rid); - args.write(prot); - prot.writeMessageEnd(); - } - - public OnlineCheck getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_pollResults(); - } - } + private static class getPackageInfo_resultTupleScheme extends TupleScheme<getPackageInfo_result> { - public void statusDownloads(org.apache.thrift.async.AsyncMethodCallback<statusDownloads_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - statusDownloads_call method_call = new statusDownloads_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetE()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetE()) { + struct.e.write(oprot); + } + } - public static class statusDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { - public statusDownloads_call(org.apache.thrift.async.AsyncMethodCallback<statusDownloads_call> 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("statusDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); - statusDownloads_args args = new statusDownloads_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<DownloadInfo> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_statusDownloads(); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = new PackageData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(true); + } + } + } - public void getPackageData(int pid, org.apache.thrift.async.AsyncMethodCallback<getPackageData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getPackageData_call method_call = new getPackageData_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); } - public static class getPackageData_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public getPackageData_call(int pid, org.apache.thrift.async.AsyncMethodCallback<getPackageData_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getPackageData_args args = new getPackageData_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public PackageData getResult() throws PackageDoesNotExists, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getPackageData(); - } - } + public static class getFileData_args implements org.apache.thrift.TBase<getFileData_args, getFileData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getFileData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileData_args"); - public void getPackageInfo(int pid, org.apache.thrift.async.AsyncMethodCallback<getPackageInfo_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getPackageInfo_call method_call = new getPackageInfo_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); - public static class getPackageInfo_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public getPackageInfo_call(int pid, org.apache.thrift.async.AsyncMethodCallback<getPackageInfo_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageInfo", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getPackageInfo_args args = new getPackageInfo_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public PackageData getResult() throws PackageDoesNotExists, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getPackageInfo(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void getFileData(int fid, org.apache.thrift.async.AsyncMethodCallback<getFileData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getFileData_call method_call = new getFileData_call(fid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + static { + schemes.put(StandardScheme.class, new getFileData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getFileData_argsTupleSchemeFactory()); + } - public static class getFileData_call extends org.apache.thrift.async.TAsyncMethodCall { - private int fid; - public getFileData_call(int fid, org.apache.thrift.async.AsyncMethodCallback<getFileData_call> 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.fid = fid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getFileData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getFileData_args args = new getFileData_args(); - args.setFid(fid); - args.write(prot); - prot.writeMessageEnd(); - } - - public FileData getResult() throws FileDoesNotExists, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getFileData(); - } - } + public int fid; // required - public void getQueue(org.apache.thrift.async.AsyncMethodCallback<getQueue_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getQueue_call method_call = new getQueue_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public static class getQueue_call extends org.apache.thrift.async.TAsyncMethodCall { - public getQueue_call(org.apache.thrift.async.AsyncMethodCallback<getQueue_call> 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("getQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getQueue_args args = new getQueue_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<PackageData> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getQueue(); - } - } + out.writeInt(fid); + } - public void getCollector(org.apache.thrift.async.AsyncMethodCallback<getCollector_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getCollector_call method_call = new getCollector_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public int describeContents() { + return 0; + } - public static class getCollector_call extends org.apache.thrift.async.TAsyncMethodCall { - public getCollector_call(org.apache.thrift.async.AsyncMethodCallback<getCollector_call> 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("getCollector", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getCollector_args args = new getCollector_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<PackageData> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getCollector(); - } - } + public getFileData_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void getQueueData(org.apache.thrift.async.AsyncMethodCallback<getQueueData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getQueueData_call method_call = new getQueueData_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + this.fid = in.readInt(); + } - public static class getQueueData_call extends org.apache.thrift.async.TAsyncMethodCall { - public getQueueData_call(org.apache.thrift.async.AsyncMethodCallback<getQueueData_call> 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("getQueueData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getQueueData_args args = new getQueueData_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<PackageData> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getQueueData(); - } - } + public static final android.os.Parcelable.Creator<getFileData_args> CREATOR = new android.os.Parcelable.Creator<getFileData_args>() { + @Override + public getFileData_args[] newArray(int size) { + return new getFileData_args[size]; + } - public void getCollectorData(org.apache.thrift.async.AsyncMethodCallback<getCollectorData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getCollectorData_call method_call = new getCollectorData_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public getFileData_args createFromParcel(android.os.Parcel in) { + return new getFileData_args(in); + } + }; - public static class getCollectorData_call extends org.apache.thrift.async.TAsyncMethodCall { - public getCollectorData_call(org.apache.thrift.async.AsyncMethodCallback<getCollectorData_call> 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("getCollectorData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getCollectorData_args args = new getCollectorData_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<PackageData> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getCollectorData(); - } - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"); - public void getPackageOrder(Destination destination, org.apache.thrift.async.AsyncMethodCallback<getPackageOrder_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getPackageOrder_call method_call = new getPackageOrder_call(destination, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public static class getPackageOrder_call extends org.apache.thrift.async.TAsyncMethodCall { - private Destination destination; - public getPackageOrder_call(Destination destination, org.apache.thrift.async.AsyncMethodCallback<getPackageOrder_call> 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.destination = destination; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getPackageOrder", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getPackageOrder_args args = new getPackageOrder_args(); - args.setDestination(destination); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<Short,Integer> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getPackageOrder(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void getFileOrder(int pid, org.apache.thrift.async.AsyncMethodCallback<getFileOrder_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getFileOrder_call method_call = new getFileOrder_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FID + return FID; + default: + return null; + } + } - public static class getFileOrder_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public getFileOrder_call(int pid, org.apache.thrift.async.AsyncMethodCallback<getFileOrder_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getFileOrder", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getFileOrder_args args = new getFileOrder_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<Short,Integer> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getFileOrder(); - } - } + /** + * 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; + } - public void generateAndAddPackages(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<generateAndAddPackages_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - generateAndAddPackages_call method_call = new generateAndAddPackages_call(links, dest, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public static class generateAndAddPackages_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<String> links; - private Destination dest; - public generateAndAddPackages_call(List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<generateAndAddPackages_call> 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.links = links; - this.dest = dest; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("generateAndAddPackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); - generateAndAddPackages_args args = new generateAndAddPackages_args(); - args.setLinks(links); - args.setDest(dest); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<Integer> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_generateAndAddPackages(); - } - } + private final short _thriftId; + private final String _fieldName; - public void addPackage(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<addPackage_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - addPackage_call method_call = new addPackage_call(name, links, dest, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public static class addPackage_call extends org.apache.thrift.async.TAsyncMethodCall { - private String name; - private List<String> links; - private Destination dest; - public addPackage_call(String name, List<String> links, Destination dest, org.apache.thrift.async.AsyncMethodCallback<addPackage_call> 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; - this.links = links; - this.dest = dest; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - addPackage_args args = new addPackage_args(); - args.setName(name); - args.setLinks(links); - args.setDest(dest); - args.write(prot); - prot.writeMessageEnd(); - } - - public int getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_addPackage(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - public void addFiles(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback<addFiles_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - addFiles_call method_call = new addFiles_call(pid, links, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public String getFieldName() { + return _fieldName; + } + } - public static class addFiles_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - private List<String> links; - public addFiles_call(int pid, List<String> links, org.apache.thrift.async.AsyncMethodCallback<addFiles_call> 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.pid = pid; - this.links = links; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("addFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); - addFiles_args args = new addFiles_args(); - args.setPid(pid); - args.setLinks(links); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_addFiles(); - } - } + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void uploadContainer(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<uploadContainer_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - uploadContainer_call method_call = new uploadContainer_call(filename, data, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileData_args.class, metaDataMap); + } - public static class uploadContainer_call extends org.apache.thrift.async.TAsyncMethodCall { - private String filename; - private ByteBuffer data; - public uploadContainer_call(String filename, ByteBuffer data, org.apache.thrift.async.AsyncMethodCallback<uploadContainer_call> 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.filename = filename; - this.data = data; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("uploadContainer", org.apache.thrift.protocol.TMessageType.CALL, 0)); - uploadContainer_args args = new uploadContainer_args(); - args.setFilename(filename); - args.setData(data); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_uploadContainer(); - } - } + public getFileData_args() { + } - public void deleteFiles(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<deleteFiles_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - deleteFiles_call method_call = new deleteFiles_call(fids, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public getFileData_args( + int fid) { + this(); + this.fid = fid; + setFidIsSet(true); + } - public static class deleteFiles_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<Integer> fids; - public deleteFiles_call(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<deleteFiles_call> 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.fids = fids; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deleteFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); - deleteFiles_args args = new deleteFiles_args(); - args.setFids(fids); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_deleteFiles(); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getFileData_args(getFileData_args other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; + } - public void deletePackages(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback<deletePackages_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - deletePackages_call method_call = new deletePackages_call(pids, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public getFileData_args deepCopy() { + return new getFileData_args(this); + } - public static class deletePackages_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<Integer> pids; - public deletePackages_call(List<Integer> pids, org.apache.thrift.async.AsyncMethodCallback<deletePackages_call> 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.pids = pids; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("deletePackages", org.apache.thrift.protocol.TMessageType.CALL, 0)); - deletePackages_args args = new deletePackages_args(); - args.setPids(pids); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_deletePackages(); - } - } + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + } - public void pushToQueue(int pid, org.apache.thrift.async.AsyncMethodCallback<pushToQueue_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - pushToQueue_call method_call = new pushToQueue_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public int getFid() { + return this.fid; + } - public static class pushToQueue_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public pushToQueue_call(int pid, org.apache.thrift.async.AsyncMethodCallback<pushToQueue_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pushToQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); - pushToQueue_args args = new pushToQueue_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_pushToQueue(); - } - } + public getFileData_args setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; + } - public void pullFromQueue(int pid, org.apache.thrift.async.AsyncMethodCallback<pullFromQueue_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - pullFromQueue_call method_call = new pullFromQueue_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } - public static class pullFromQueue_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public pullFromQueue_call(int pid, org.apache.thrift.async.AsyncMethodCallback<pullFromQueue_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("pullFromQueue", org.apache.thrift.protocol.TMessageType.CALL, 0)); - pullFromQueue_args args = new pullFromQueue_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_pullFromQueue(); - } - } + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); + } - public void restartPackage(int pid, org.apache.thrift.async.AsyncMethodCallback<restartPackage_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - restartPackage_call method_call = new restartPackage_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); + } - public static class restartPackage_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public restartPackage_call(int pid, org.apache.thrift.async.AsyncMethodCallback<restartPackage_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restartPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - restartPackage_args args = new restartPackage_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_restartPackage(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; - public void restartFile(int fid, org.apache.thrift.async.AsyncMethodCallback<restartFile_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - restartFile_call method_call = new restartFile_call(fid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + } + } - public static class restartFile_call extends org.apache.thrift.async.TAsyncMethodCall { - private int fid; - public restartFile_call(int fid, org.apache.thrift.async.AsyncMethodCallback<restartFile_call> 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.fid = fid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("restartFile", org.apache.thrift.protocol.TMessageType.CALL, 0)); - restartFile_args args = new restartFile_args(); - args.setFid(fid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_restartFile(); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); - public void recheckPackage(int pid, org.apache.thrift.async.AsyncMethodCallback<recheckPackage_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - recheckPackage_call method_call = new recheckPackage_call(pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + } + throw new IllegalStateException(); + } - public static class recheckPackage_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - public recheckPackage_call(int pid, org.apache.thrift.async.AsyncMethodCallback<recheckPackage_call> 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.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("recheckPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - recheckPackage_args args = new recheckPackage_args(); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_recheckPackage(); - } - } + /** 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(); + } - public void stopAllDownloads(org.apache.thrift.async.AsyncMethodCallback<stopAllDownloads_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - stopAllDownloads_call method_call = new stopAllDownloads_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + switch (field) { + case FID: + return isSetFid(); + } + throw new IllegalStateException(); + } - public static class stopAllDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { - public stopAllDownloads_call(org.apache.thrift.async.AsyncMethodCallback<stopAllDownloads_call> 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("stopAllDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); - stopAllDownloads_args args = new stopAllDownloads_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_stopAllDownloads(); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getFileData_args) + return this.equals((getFileData_args) that); + return false; + } - public void stopDownloads(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<stopDownloads_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - stopDownloads_call method_call = new stopDownloads_call(fids, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public boolean equals(getFileData_args that) { + if (that == null) + return false; - public static class stopDownloads_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<Integer> fids; - public stopDownloads_call(List<Integer> fids, org.apache.thrift.async.AsyncMethodCallback<stopDownloads_call> 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.fids = fids; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("stopDownloads", org.apache.thrift.protocol.TMessageType.CALL, 0)); - stopDownloads_args args = new stopDownloads_args(); - args.setFids(fids); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_stopDownloads(); - } - } + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + return false; + } - public void setPackageName(int pid, String name, org.apache.thrift.async.AsyncMethodCallback<setPackageName_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - setPackageName_call method_call = new setPackageName_call(pid, name, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + return true; + } - public static class setPackageName_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - private String name; - public setPackageName_call(int pid, String name, org.apache.thrift.async.AsyncMethodCallback<setPackageName_call> 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.pid = pid; - 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("setPackageName", org.apache.thrift.protocol.TMessageType.CALL, 0)); - setPackageName_args args = new setPackageName_args(); - args.setPid(pid); - args.setName(name); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_setPackageName(); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void movePackage(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback<movePackage_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - movePackage_call method_call = new movePackage_call(destination, pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); - public static class movePackage_call extends org.apache.thrift.async.TAsyncMethodCall { - private Destination destination; - private int pid; - public movePackage_call(Destination destination, int pid, org.apache.thrift.async.AsyncMethodCallback<movePackage_call> 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.destination = destination; - this.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("movePackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - movePackage_args args = new movePackage_args(); - args.setDestination(destination); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_movePackage(); - } - } + return list.hashCode(); + } - public void moveFiles(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback<moveFiles_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - moveFiles_call method_call = new moveFiles_call(fids, pid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public int compareTo(getFileData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public static class moveFiles_call extends org.apache.thrift.async.TAsyncMethodCall { - private List<Integer> fids; - private int pid; - public moveFiles_call(List<Integer> fids, int pid, org.apache.thrift.async.AsyncMethodCallback<moveFiles_call> 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.fids = fids; - this.pid = pid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("moveFiles", org.apache.thrift.protocol.TMessageType.CALL, 0)); - moveFiles_args args = new moveFiles_args(); - args.setFids(fids); - args.setPid(pid); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_moveFiles(); - } - } + int lastComparison = 0; - public void orderPackage(int pid, short position, org.apache.thrift.async.AsyncMethodCallback<orderPackage_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - orderPackage_call method_call = new orderPackage_call(pid, position, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public static class orderPackage_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - private short position; - public orderPackage_call(int pid, short position, org.apache.thrift.async.AsyncMethodCallback<orderPackage_call> 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.pid = pid; - this.position = position; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("orderPackage", org.apache.thrift.protocol.TMessageType.CALL, 0)); - orderPackage_args args = new orderPackage_args(); - args.setPid(pid); - args.setPosition(position); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_orderPackage(); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void orderFile(int fid, short position, org.apache.thrift.async.AsyncMethodCallback<orderFile_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - orderFile_call method_call = new orderFile_call(fid, position, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public static class orderFile_call extends org.apache.thrift.async.TAsyncMethodCall { - private int fid; - private short position; - public orderFile_call(int fid, short position, org.apache.thrift.async.AsyncMethodCallback<orderFile_call> 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.fid = fid; - this.position = position; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("orderFile", org.apache.thrift.protocol.TMessageType.CALL, 0)); - orderFile_args args = new orderFile_args(); - args.setFid(fid); - args.setPosition(position); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_orderFile(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void setPackageData(int pid, Map<String,String> data, org.apache.thrift.async.AsyncMethodCallback<setPackageData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - setPackageData_call method_call = new setPackageData_call(pid, data, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getFileData_args("); + boolean first = true; - public static class setPackageData_call extends org.apache.thrift.async.TAsyncMethodCall { - private int pid; - private Map<String,String> data; - public setPackageData_call(int pid, Map<String,String> data, org.apache.thrift.async.AsyncMethodCallback<setPackageData_call> 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.pid = pid; - this.data = data; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setPackageData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - setPackageData_args args = new setPackageData_args(); - args.setPid(pid); - args.setData(data); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws PackageDoesNotExists, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_setPackageData(); - } - } + sb.append("fid:"); + sb.append(this.fid); + first = false; + sb.append(")"); + return sb.toString(); + } - public void deleteFinished(org.apache.thrift.async.AsyncMethodCallback<deleteFinished_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - deleteFinished_call method_call = new deleteFinished_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public static class deleteFinished_call extends org.apache.thrift.async.TAsyncMethodCall { - public deleteFinished_call(org.apache.thrift.async.AsyncMethodCallback<deleteFinished_call> 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("deleteFinished", org.apache.thrift.protocol.TMessageType.CALL, 0)); - deleteFinished_args args = new deleteFinished_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<Integer> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_deleteFinished(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void restartFailed(org.apache.thrift.async.AsyncMethodCallback<restartFailed_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - restartFailed_call method_call = new restartFailed_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public static class restartFailed_call extends org.apache.thrift.async.TAsyncMethodCall { - public restartFailed_call(org.apache.thrift.async.AsyncMethodCallback<restartFailed_call> 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("restartFailed", org.apache.thrift.protocol.TMessageType.CALL, 0)); - restartFailed_args args = new restartFailed_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_restartFailed(); - } - } + private static class getFileData_argsStandardSchemeFactory implements SchemeFactory { + public getFileData_argsStandardScheme getScheme() { + return new getFileData_argsStandardScheme(); + } + } - public void isCaptchaWaiting(org.apache.thrift.async.AsyncMethodCallback<isCaptchaWaiting_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - isCaptchaWaiting_call method_call = new isCaptchaWaiting_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static class getFileData_argsStandardScheme extends StandardScheme<getFileData_args> { - public static class isCaptchaWaiting_call extends org.apache.thrift.async.TAsyncMethodCall { - public isCaptchaWaiting_call(org.apache.thrift.async.AsyncMethodCallback<isCaptchaWaiting_call> 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("isCaptchaWaiting", org.apache.thrift.protocol.TMessageType.CALL, 0)); - isCaptchaWaiting_args args = new isCaptchaWaiting_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_isCaptchaWaiting(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getFileData_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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(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(); - public void getCaptchaTask(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback<getCaptchaTask_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getCaptchaTask_call method_call = new getCaptchaTask_call(exclusive, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public static class getCaptchaTask_call extends org.apache.thrift.async.TAsyncMethodCall { - private boolean exclusive; - public getCaptchaTask_call(boolean exclusive, org.apache.thrift.async.AsyncMethodCallback<getCaptchaTask_call> 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.exclusive = exclusive; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCaptchaTask", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getCaptchaTask_args args = new getCaptchaTask_args(); - args.setExclusive(exclusive); - args.write(prot); - prot.writeMessageEnd(); - } - - public CaptchaTask getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getCaptchaTask(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getFileData_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void getCaptchaTaskStatus(int tid, org.apache.thrift.async.AsyncMethodCallback<getCaptchaTaskStatus_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getCaptchaTaskStatus_call method_call = new getCaptchaTaskStatus_call(tid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public static class getCaptchaTaskStatus_call extends org.apache.thrift.async.TAsyncMethodCall { - private int tid; - public getCaptchaTaskStatus_call(int tid, org.apache.thrift.async.AsyncMethodCallback<getCaptchaTaskStatus_call> 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.tid = tid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getCaptchaTaskStatus", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getCaptchaTaskStatus_args args = new getCaptchaTaskStatus_args(); - args.setTid(tid); - args.write(prot); - prot.writeMessageEnd(); - } - - public String getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getCaptchaTaskStatus(); - } - } + } - public void setCaptchaResult(int tid, String result, org.apache.thrift.async.AsyncMethodCallback<setCaptchaResult_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - setCaptchaResult_call method_call = new setCaptchaResult_call(tid, result, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static class getFileData_argsTupleSchemeFactory implements SchemeFactory { + public getFileData_argsTupleScheme getScheme() { + return new getFileData_argsTupleScheme(); + } + } - public static class setCaptchaResult_call extends org.apache.thrift.async.TAsyncMethodCall { - private int tid; - private String result; - public setCaptchaResult_call(int tid, String result, org.apache.thrift.async.AsyncMethodCallback<setCaptchaResult_call> 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.tid = tid; - this.result = result; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("setCaptchaResult", org.apache.thrift.protocol.TMessageType.CALL, 0)); - setCaptchaResult_args args = new setCaptchaResult_args(); - args.setTid(tid); - args.setResult(result); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_setCaptchaResult(); - } - } + private static class getFileData_argsTupleScheme extends TupleScheme<getFileData_args> { - public void getEvents(String uuid, org.apache.thrift.async.AsyncMethodCallback<getEvents_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getEvents_call method_call = new getEvents_call(uuid, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getFileData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + } - public static class getEvents_call extends org.apache.thrift.async.TAsyncMethodCall { - private String uuid; - public getEvents_call(String uuid, org.apache.thrift.async.AsyncMethodCallback<getEvents_call> 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.uuid = uuid; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getEvents", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getEvents_args args = new getEvents_args(); - args.setUuid(uuid); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<EventInfo> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getEvents(); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getFileData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + } + } - public void getAccounts(boolean refresh, org.apache.thrift.async.AsyncMethodCallback<getAccounts_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getAccounts_call method_call = new getAccounts_call(refresh, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); } - public static class getAccounts_call extends org.apache.thrift.async.TAsyncMethodCall { - private boolean refresh; - public getAccounts_call(boolean refresh, org.apache.thrift.async.AsyncMethodCallback<getAccounts_call> 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.refresh = refresh; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAccounts", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getAccounts_args args = new getAccounts_args(); - args.setRefresh(refresh); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<AccountInfo> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getAccounts(); - } - } + public static class getFileData_result implements org.apache.thrift.TBase<getFileData_result, getFileData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getFileData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileData_result"); - public void getAccountTypes(org.apache.thrift.async.AsyncMethodCallback<getAccountTypes_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getAccountTypes_call method_call = new getAccountTypes_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + 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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short) 1); - public static class getAccountTypes_call extends org.apache.thrift.async.TAsyncMethodCall { - public getAccountTypes_call(org.apache.thrift.async.AsyncMethodCallback<getAccountTypes_call> 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("getAccountTypes", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getAccountTypes_args args = new getAccountTypes_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public List<String> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getAccountTypes(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void updateAccount(String plugin, String account, String password, Map<String,String> options, org.apache.thrift.async.AsyncMethodCallback<updateAccount_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - updateAccount_call method_call = new updateAccount_call(plugin, account, password, options, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + static { + schemes.put(StandardScheme.class, new getFileData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getFileData_resultTupleSchemeFactory()); + } - public static class updateAccount_call extends org.apache.thrift.async.TAsyncMethodCall { - private String plugin; - private String account; - private String password; - private Map<String,String> options; - public updateAccount_call(String plugin, String account, String password, Map<String,String> options, org.apache.thrift.async.AsyncMethodCallback<updateAccount_call> 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.plugin = plugin; - this.account = account; - this.password = password; - this.options = options; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("updateAccount", org.apache.thrift.protocol.TMessageType.CALL, 0)); - updateAccount_args args = new updateAccount_args(); - args.setPlugin(plugin); - args.setAccount(account); - args.setPassword(password); - args.setOptions(options); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_updateAccount(); - } - } + public FileData success; // required + public FileDoesNotExists e; // required - public void removeAccount(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback<removeAccount_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - removeAccount_call method_call = new removeAccount_call(plugin, account, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } - public static class removeAccount_call extends org.apache.thrift.async.TAsyncMethodCall { - private String plugin; - private String account; - public removeAccount_call(String plugin, String account, org.apache.thrift.async.AsyncMethodCallback<removeAccount_call> 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.plugin = plugin; - this.account = account; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("removeAccount", org.apache.thrift.protocol.TMessageType.CALL, 0)); - removeAccount_args args = new removeAccount_args(); - args.setPlugin(plugin); - args.setAccount(account); - args.write(prot); - prot.writeMessageEnd(); - } - - public void getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - (new Client(prot)).recv_removeAccount(); - } - } + @Override + public int describeContents() { + return 0; + } - public void login(String username, String password, org.apache.thrift.async.AsyncMethodCallback<login_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - login_call method_call = new login_call(username, password, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public getFileData_result(android.os.Parcel in) { + this.success = in.readParcelable(getFileData_result.class.getClassLoader()); + } - public static class login_call extends org.apache.thrift.async.TAsyncMethodCall { - private String username; - private String password; - public login_call(String username, String password, org.apache.thrift.async.AsyncMethodCallback<login_call> 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.username = username; - this.password = password; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("login", org.apache.thrift.protocol.TMessageType.CALL, 0)); - login_args args = new login_args(); - args.setUsername(username); - args.setPassword(password); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_login(); - } - } + public static final android.os.Parcelable.Creator<getFileData_result> CREATOR = new android.os.Parcelable.Creator<getFileData_result>() { + @Override + public getFileData_result[] newArray(int size) { + return new getFileData_result[size]; + } - public void getUserData(String username, String password, org.apache.thrift.async.AsyncMethodCallback<getUserData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getUserData_call method_call = new getUserData_call(username, password, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + @Override + public getFileData_result createFromParcel(android.os.Parcel in) { + return new getFileData_result(in); + } + }; - public static class getUserData_call extends org.apache.thrift.async.TAsyncMethodCall { - private String username; - private String password; - public getUserData_call(String username, String password, org.apache.thrift.async.AsyncMethodCallback<getUserData_call> 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.username = username; - this.password = password; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getUserData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getUserData_args args = new getUserData_args(); - args.setUsername(username); - args.setPassword(password); - args.write(prot); - prot.writeMessageEnd(); - } - - public UserData getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getUserData(); - } - } + /** 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"), + E((short) 1, "e"); - public void getAllUserData(org.apache.thrift.async.AsyncMethodCallback<getAllUserData_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getAllUserData_call method_call = new getAllUserData_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public static class getAllUserData_call extends org.apache.thrift.async.TAsyncMethodCall { - public getAllUserData_call(org.apache.thrift.async.AsyncMethodCallback<getAllUserData_call> 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("getAllUserData", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getAllUserData_args args = new getAllUserData_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,UserData> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getAllUserData(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void getServices(org.apache.thrift.async.AsyncMethodCallback<getServices_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getServices_call method_call = new getServices_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // E + return E; + default: + return null; + } + } - public static class getServices_call extends org.apache.thrift.async.TAsyncMethodCall { - public getServices_call(org.apache.thrift.async.AsyncMethodCallback<getServices_call> 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("getServices", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getServices_args args = new getServices_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,Map<String,String>> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getServices(); - } - } + /** + * 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; + } - public void hasService(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback<hasService_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - hasService_call method_call = new hasService_call(plugin, func, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public static class hasService_call extends org.apache.thrift.async.TAsyncMethodCall { - private String plugin; - private String func; - public hasService_call(String plugin, String func, org.apache.thrift.async.AsyncMethodCallback<hasService_call> 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.plugin = plugin; - this.func = func; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("hasService", org.apache.thrift.protocol.TMessageType.CALL, 0)); - hasService_args args = new hasService_args(); - args.setPlugin(plugin); - args.setFunc(func); - args.write(prot); - prot.writeMessageEnd(); - } - - public boolean getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_hasService(); - } - } + private final short _thriftId; + private final String _fieldName; - public void call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback<call_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - call_call method_call = new call_call(info, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public static class call_call extends org.apache.thrift.async.TAsyncMethodCall { - private ServiceCall info; - public call_call(ServiceCall info, org.apache.thrift.async.AsyncMethodCallback<call_call> 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("call", org.apache.thrift.protocol.TMessageType.CALL, 0)); - call_args args = new call_args(); - args.setInfo(info); - args.write(prot); - prot.writeMessageEnd(); - } - - public String getResult() throws ServiceDoesNotExists, ServiceException, org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_call(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - public void getAllInfo(org.apache.thrift.async.AsyncMethodCallback<getAllInfo_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getAllInfo_call method_call = new getAllInfo_call(resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + public String getFieldName() { + return _fieldName; + } + } - public static class getAllInfo_call extends org.apache.thrift.async.TAsyncMethodCall { - public getAllInfo_call(org.apache.thrift.async.AsyncMethodCallback<getAllInfo_call> 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("getAllInfo", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getAllInfo_args args = new getAllInfo_args(); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,Map<String,String>> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getAllInfo(); - } - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void getInfoByPlugin(String plugin, org.apache.thrift.async.AsyncMethodCallback<getInfoByPlugin_call> resultHandler) throws org.apache.thrift.TException { - checkReady(); - getInfoByPlugin_call method_call = new getInfoByPlugin_call(plugin, resultHandler, this, ___protocolFactory, ___transport); - this.___currentMethod = method_call; - ___manager.call(method_call); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, FileData.class))); + tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileData_result.class, metaDataMap); + } - public static class getInfoByPlugin_call extends org.apache.thrift.async.TAsyncMethodCall { - private String plugin; - public getInfoByPlugin_call(String plugin, org.apache.thrift.async.AsyncMethodCallback<getInfoByPlugin_call> 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.plugin = plugin; - } - - public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException { - prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getInfoByPlugin", org.apache.thrift.protocol.TMessageType.CALL, 0)); - getInfoByPlugin_args args = new getInfoByPlugin_args(); - args.setPlugin(plugin); - args.write(prot); - prot.writeMessageEnd(); - } - - public Map<String,String> getResult() throws org.apache.thrift.TException { - if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) { - throw new IllegalStateException("Method call not finished!"); - } - org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array()); - org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport); - return (new Client(prot)).recv_getInfoByPlugin(); - } - } + public getFileData_result() { + } - } + public getFileData_result( + FileData success, + FileDoesNotExists e) { + this(); + this.success = success; + this.e = e; + } - public static class Processor<I extends Iface> extends org.apache.thrift.TBaseProcessor implements org.apache.thrift.TProcessor { - private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName()); - public Processor(I iface) { - super(iface, getProcessMap(new HashMap<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>>())); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getFileData_result(getFileData_result other) { + if (other.isSetSuccess()) { + this.success = new FileData(other.success); + } + if (other.isSetE()) { + this.e = new FileDoesNotExists(other.e); + } + } - protected Processor(I iface, Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) { - super(iface, getProcessMap(processMap)); - } + public getFileData_result deepCopy() { + return new getFileData_result(this); + } - private static <I extends Iface> Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> getProcessMap(Map<String, org.apache.thrift.ProcessFunction<I, ? extends org.apache.thrift.TBase>> processMap) { - processMap.put("getConfigValue", new getConfigValue()); - processMap.put("setConfigValue", new setConfigValue()); - processMap.put("getConfig", new getConfig()); - processMap.put("getPluginConfig", new getPluginConfig()); - processMap.put("pauseServer", new pauseServer()); - processMap.put("unpauseServer", new unpauseServer()); - processMap.put("togglePause", new togglePause()); - processMap.put("statusServer", new statusServer()); - processMap.put("freeSpace", new freeSpace()); - processMap.put("getServerVersion", new getServerVersion()); - processMap.put("kill", new kill()); - processMap.put("restart", new restart()); - processMap.put("getLog", new getLog()); - processMap.put("isTimeDownload", new isTimeDownload()); - processMap.put("isTimeReconnect", new isTimeReconnect()); - processMap.put("toggleReconnect", new toggleReconnect()); - processMap.put("generatePackages", new generatePackages()); - processMap.put("checkURLs", new checkURLs()); - processMap.put("parseURLs", new parseURLs()); - processMap.put("checkOnlineStatus", new checkOnlineStatus()); - processMap.put("checkOnlineStatusContainer", new checkOnlineStatusContainer()); - processMap.put("pollResults", new pollResults()); - processMap.put("statusDownloads", new statusDownloads()); - processMap.put("getPackageData", new getPackageData()); - processMap.put("getPackageInfo", new getPackageInfo()); - processMap.put("getFileData", new getFileData()); - processMap.put("getQueue", new getQueue()); - processMap.put("getCollector", new getCollector()); - processMap.put("getQueueData", new getQueueData()); - processMap.put("getCollectorData", new getCollectorData()); - processMap.put("getPackageOrder", new getPackageOrder()); - processMap.put("getFileOrder", new getFileOrder()); - processMap.put("generateAndAddPackages", new generateAndAddPackages()); - processMap.put("addPackage", new addPackage()); - processMap.put("addFiles", new addFiles()); - processMap.put("uploadContainer", new uploadContainer()); - processMap.put("deleteFiles", new deleteFiles()); - processMap.put("deletePackages", new deletePackages()); - processMap.put("pushToQueue", new pushToQueue()); - processMap.put("pullFromQueue", new pullFromQueue()); - processMap.put("restartPackage", new restartPackage()); - processMap.put("restartFile", new restartFile()); - processMap.put("recheckPackage", new recheckPackage()); - processMap.put("stopAllDownloads", new stopAllDownloads()); - processMap.put("stopDownloads", new stopDownloads()); - processMap.put("setPackageName", new setPackageName()); - processMap.put("movePackage", new movePackage()); - processMap.put("moveFiles", new moveFiles()); - processMap.put("orderPackage", new orderPackage()); - processMap.put("orderFile", new orderFile()); - processMap.put("setPackageData", new setPackageData()); - processMap.put("deleteFinished", new deleteFinished()); - processMap.put("restartFailed", new restartFailed()); - processMap.put("isCaptchaWaiting", new isCaptchaWaiting()); - processMap.put("getCaptchaTask", new getCaptchaTask()); - processMap.put("getCaptchaTaskStatus", new getCaptchaTaskStatus()); - processMap.put("setCaptchaResult", new setCaptchaResult()); - processMap.put("getEvents", new getEvents()); - processMap.put("getAccounts", new getAccounts()); - processMap.put("getAccountTypes", new getAccountTypes()); - processMap.put("updateAccount", new updateAccount()); - processMap.put("removeAccount", new removeAccount()); - processMap.put("login", new login()); - processMap.put("getUserData", new getUserData()); - processMap.put("getAllUserData", new getAllUserData()); - processMap.put("getServices", new getServices()); - processMap.put("hasService", new hasService()); - processMap.put("call", new call()); - processMap.put("getAllInfo", new getAllInfo()); - processMap.put("getInfoByPlugin", new getInfoByPlugin()); - return processMap; - } + @Override + public void clear() { + this.success = null; + this.e = null; + } - private static class getConfigValue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getConfigValue_args> { - public getConfigValue() { - super("getConfigValue"); - } + public FileData getSuccess() { + return this.success; + } - protected getConfigValue_args getEmptyArgsInstance() { - return new getConfigValue_args(); - } + public getFileData_result setSuccess(FileData success) { + this.success = success; + return this; + } - protected getConfigValue_result getResult(I iface, getConfigValue_args args) throws org.apache.thrift.TException { - getConfigValue_result result = new getConfigValue_result(); - result.success = iface.getConfigValue(args.category, args.option, args.section); - return result; - } - } + public void unsetSuccess() { + this.success = null; + } - private static class setConfigValue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setConfigValue_args> { - public setConfigValue() { - super("setConfigValue"); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - protected setConfigValue_args getEmptyArgsInstance() { - return new setConfigValue_args(); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - protected setConfigValue_result getResult(I iface, setConfigValue_args args) throws org.apache.thrift.TException { - setConfigValue_result result = new setConfigValue_result(); - iface.setConfigValue(args.category, args.option, args.value, args.section); - return result; - } - } + public FileDoesNotExists getE() { + return this.e; + } - private static class getConfig<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getConfig_args> { - public getConfig() { - super("getConfig"); - } + public getFileData_result setE(FileDoesNotExists e) { + this.e = e; + return this; + } - protected getConfig_args getEmptyArgsInstance() { - return new getConfig_args(); - } + public void unsetE() { + this.e = null; + } - protected getConfig_result getResult(I iface, getConfig_args args) throws org.apache.thrift.TException { - getConfig_result result = new getConfig_result(); - result.success = iface.getConfig(); - return result; - } - } + /** Returns true if field e is set (has been assigned a value) and false otherwise */ + public boolean isSetE() { + return this.e != null; + } - private static class getPluginConfig<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPluginConfig_args> { - public getPluginConfig() { - super("getPluginConfig"); - } + public void setEIsSet(boolean value) { + if (!value) { + this.e = null; + } + } - protected getPluginConfig_args getEmptyArgsInstance() { - return new getPluginConfig_args(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((FileData) value); + } + break; - protected getPluginConfig_result getResult(I iface, getPluginConfig_args args) throws org.apache.thrift.TException { - getPluginConfig_result result = new getPluginConfig_result(); - result.success = iface.getPluginConfig(); - return result; - } - } + case E: + if (value == null) { + unsetE(); + } else { + setE((FileDoesNotExists) value); + } + break; - private static class pauseServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pauseServer_args> { - public pauseServer() { - super("pauseServer"); - } + } + } - protected pauseServer_args getEmptyArgsInstance() { - return new pauseServer_args(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - protected pauseServer_result getResult(I iface, pauseServer_args args) throws org.apache.thrift.TException { - pauseServer_result result = new pauseServer_result(); - iface.pauseServer(); - return result; - } - } + case E: + return getE(); - private static class unpauseServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, unpauseServer_args> { - public unpauseServer() { - super("unpauseServer"); - } + } + throw new IllegalStateException(); + } - protected unpauseServer_args getEmptyArgsInstance() { - return new unpauseServer_args(); - } + /** 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(); + } - protected unpauseServer_result getResult(I iface, unpauseServer_args args) throws org.apache.thrift.TException { - unpauseServer_result result = new unpauseServer_result(); - iface.unpauseServer(); - return result; - } - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + case E: + return isSetE(); + } + throw new IllegalStateException(); + } - private static class togglePause<I extends Iface> extends org.apache.thrift.ProcessFunction<I, togglePause_args> { - public togglePause() { - super("togglePause"); - } - - protected togglePause_args getEmptyArgsInstance() { - return new togglePause_args(); - } - - protected togglePause_result getResult(I iface, togglePause_args args) throws org.apache.thrift.TException { - togglePause_result result = new togglePause_result(); - result.success = iface.togglePause(); - result.setSuccessIsSet(true); - return result; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getFileData_result) + return this.equals((getFileData_result) that); + return false; + } - private static class statusServer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, statusServer_args> { - public statusServer() { - super("statusServer"); - } + public boolean equals(getFileData_result that) { + if (that == null) + return false; - protected statusServer_args getEmptyArgsInstance() { - return new statusServer_args(); - } + 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; + } - protected statusServer_result getResult(I iface, statusServer_args args) throws org.apache.thrift.TException { - statusServer_result result = new statusServer_result(); - result.success = iface.statusServer(); - return result; - } - } + boolean this_present_e = true && this.isSetE(); + boolean that_present_e = true && that.isSetE(); + if (this_present_e || that_present_e) { + if (!(this_present_e && that_present_e)) + return false; + if (!this.e.equals(that.e)) + return false; + } - private static class freeSpace<I extends Iface> extends org.apache.thrift.ProcessFunction<I, freeSpace_args> { - public freeSpace() { - super("freeSpace"); - } - - protected freeSpace_args getEmptyArgsInstance() { - return new freeSpace_args(); - } - - protected freeSpace_result getResult(I iface, freeSpace_args args) throws org.apache.thrift.TException { - freeSpace_result result = new freeSpace_result(); - result.success = iface.freeSpace(); - result.setSuccessIsSet(true); - return result; - } - } + return true; + } - private static class getServerVersion<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getServerVersion_args> { - public getServerVersion() { - super("getServerVersion"); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - protected getServerVersion_args getEmptyArgsInstance() { - return new getServerVersion_args(); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - protected getServerVersion_result getResult(I iface, getServerVersion_args args) throws org.apache.thrift.TException { - getServerVersion_result result = new getServerVersion_result(); - result.success = iface.getServerVersion(); - return result; - } - } + boolean present_e = true && (isSetE()); + list.add(present_e); + if (present_e) + list.add(e); - private static class kill<I extends Iface> extends org.apache.thrift.ProcessFunction<I, kill_args> { - public kill() { - super("kill"); - } + return list.hashCode(); + } - protected kill_args getEmptyArgsInstance() { - return new kill_args(); - } + @Override + public int compareTo(getFileData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - protected kill_result getResult(I iface, kill_args args) throws org.apache.thrift.TException { - kill_result result = new kill_result(); - iface.kill(); - return result; - } - } + int lastComparison = 0; - private static class restart<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restart_args> { - public restart() { - super("restart"); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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 = Boolean.valueOf(isSetE()).compareTo(other.isSetE()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetE()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, other.e); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - protected restart_args getEmptyArgsInstance() { - return new restart_args(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - protected restart_result getResult(I iface, restart_args args) throws org.apache.thrift.TException { - restart_result result = new restart_result(); - iface.restart(); - return result; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class getLog<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getLog_args> { - public getLog() { - super("getLog"); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - protected getLog_args getEmptyArgsInstance() { - return new getLog_args(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getFileData_result("); + boolean first = true; - protected getLog_result getResult(I iface, getLog_args args) throws org.apache.thrift.TException { - getLog_result result = new getLog_result(); - result.success = iface.getLog(args.offset); - return result; - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("e:"); + if (this.e == null) { + sb.append("null"); + } else { + sb.append(this.e); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class isTimeDownload<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTimeDownload_args> { - public isTimeDownload() { - super("isTimeDownload"); - } - - protected isTimeDownload_args getEmptyArgsInstance() { - return new isTimeDownload_args(); - } - - protected isTimeDownload_result getResult(I iface, isTimeDownload_args args) throws org.apache.thrift.TException { - isTimeDownload_result result = new isTimeDownload_result(); - result.success = iface.isTimeDownload(); - result.setSuccessIsSet(true); - return result; - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } - private static class isTimeReconnect<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isTimeReconnect_args> { - public isTimeReconnect() { - super("isTimeReconnect"); - } - - protected isTimeReconnect_args getEmptyArgsInstance() { - return new isTimeReconnect_args(); - } - - protected isTimeReconnect_result getResult(I iface, isTimeReconnect_args args) throws org.apache.thrift.TException { - isTimeReconnect_result result = new isTimeReconnect_result(); - result.success = iface.isTimeReconnect(); - result.setSuccessIsSet(true); - return result; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class toggleReconnect<I extends Iface> extends org.apache.thrift.ProcessFunction<I, toggleReconnect_args> { - public toggleReconnect() { - super("toggleReconnect"); - } - - protected toggleReconnect_args getEmptyArgsInstance() { - return new toggleReconnect_args(); - } - - protected toggleReconnect_result getResult(I iface, toggleReconnect_args args) throws org.apache.thrift.TException { - toggleReconnect_result result = new toggleReconnect_result(); - result.success = iface.toggleReconnect(); - result.setSuccessIsSet(true); - return result; - } - } + 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 generatePackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, generatePackages_args> { - public generatePackages() { - super("generatePackages"); - } + private static class getFileData_resultStandardSchemeFactory implements SchemeFactory { + public getFileData_resultStandardScheme getScheme() { + return new getFileData_resultStandardScheme(); + } + } - protected generatePackages_args getEmptyArgsInstance() { - return new generatePackages_args(); - } + private static class getFileData_resultStandardScheme extends StandardScheme<getFileData_result> { - protected generatePackages_result getResult(I iface, generatePackages_args args) throws org.apache.thrift.TException { - generatePackages_result result = new generatePackages_result(); - result.success = iface.generatePackages(args.links); - return result; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getFileData_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 FileData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 1: // E + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.e = new FileDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(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(); - private static class checkURLs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkURLs_args> { - public checkURLs() { - super("checkURLs"); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - protected checkURLs_args getEmptyArgsInstance() { - return new checkURLs_args(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getFileData_result struct) throws org.apache.thrift.TException { + struct.validate(); - protected checkURLs_result getResult(I iface, checkURLs_args args) throws org.apache.thrift.TException { - checkURLs_result result = new checkURLs_result(); - result.success = iface.checkURLs(args.urls); - return result; - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.e != null) { + oprot.writeFieldBegin(E_FIELD_DESC); + struct.e.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class parseURLs<I extends Iface> extends org.apache.thrift.ProcessFunction<I, parseURLs_args> { - public parseURLs() { - super("parseURLs"); - } + } - protected parseURLs_args getEmptyArgsInstance() { - return new parseURLs_args(); - } + private static class getFileData_resultTupleSchemeFactory implements SchemeFactory { + public getFileData_resultTupleScheme getScheme() { + return new getFileData_resultTupleScheme(); + } + } - protected parseURLs_result getResult(I iface, parseURLs_args args) throws org.apache.thrift.TException { - parseURLs_result result = new parseURLs_result(); - result.success = iface.parseURLs(args.html, args.url); - return result; - } - } + private static class getFileData_resultTupleScheme extends TupleScheme<getFileData_result> { - private static class checkOnlineStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkOnlineStatus_args> { - public checkOnlineStatus() { - super("checkOnlineStatus"); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getFileData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetE()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + if (struct.isSetE()) { + struct.e.write(oprot); + } + } - protected checkOnlineStatus_args getEmptyArgsInstance() { - return new checkOnlineStatus_args(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getFileData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.success = new FileData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.e = new FileDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(true); + } + } + } - protected checkOnlineStatus_result getResult(I iface, checkOnlineStatus_args args) throws org.apache.thrift.TException { - checkOnlineStatus_result result = new checkOnlineStatus_result(); - result.success = iface.checkOnlineStatus(args.urls); - return result; - } } - private static class checkOnlineStatusContainer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, checkOnlineStatusContainer_args> { - public checkOnlineStatusContainer() { - super("checkOnlineStatusContainer"); - } + public static class getQueue_args implements org.apache.thrift.TBase<getQueue_args, getQueue_args._Fields>, java.io.Serializable, Cloneable, Comparable<getQueue_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueue_args"); - protected checkOnlineStatusContainer_args getEmptyArgsInstance() { - return new checkOnlineStatusContainer_args(); - } - protected checkOnlineStatusContainer_result getResult(I iface, checkOnlineStatusContainer_args args) throws org.apache.thrift.TException { - checkOnlineStatusContainer_result result = new checkOnlineStatusContainer_result(); - result.success = iface.checkOnlineStatusContainer(args.urls, args.filename, args.data); - return result; - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class pollResults<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pollResults_args> { - public pollResults() { - super("pollResults"); - } + static { + schemes.put(StandardScheme.class, new getQueue_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getQueue_argsTupleSchemeFactory()); + } - protected pollResults_args getEmptyArgsInstance() { - return new pollResults_args(); - } - protected pollResults_result getResult(I iface, pollResults_args args) throws org.apache.thrift.TException { - pollResults_result result = new pollResults_result(); - result.success = iface.pollResults(args.rid); - return result; - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - private static class statusDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, statusDownloads_args> { - public statusDownloads() { - super("statusDownloads"); - } + @Override + public int describeContents() { + return 0; + } - protected statusDownloads_args getEmptyArgsInstance() { - return new statusDownloads_args(); - } + public getQueue_args(android.os.Parcel in) { + } - protected statusDownloads_result getResult(I iface, statusDownloads_args args) throws org.apache.thrift.TException { - statusDownloads_result result = new statusDownloads_result(); - result.success = iface.statusDownloads(); - return result; - } - } + public static final android.os.Parcelable.Creator<getQueue_args> CREATOR = new android.os.Parcelable.Creator<getQueue_args>() { + @Override + public getQueue_args[] newArray(int size) { + return new getQueue_args[size]; + } - private static class getPackageData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageData_args> { - public getPackageData() { - super("getPackageData"); - } + @Override + public getQueue_args createFromParcel(android.os.Parcel in) { + return new getQueue_args(in); + } + }; - protected getPackageData_args getEmptyArgsInstance() { - return new getPackageData_args(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - protected getPackageData_result getResult(I iface, getPackageData_args args) throws org.apache.thrift.TException { - getPackageData_result result = new getPackageData_result(); - try { - result.success = iface.getPackageData(args.pid); - } catch (PackageDoesNotExists e) { - result.e = e; - } - return result; - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class getPackageInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageInfo_args> { - public getPackageInfo() { - super("getPackageInfo"); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - protected getPackageInfo_args getEmptyArgsInstance() { - return new getPackageInfo_args(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - protected getPackageInfo_result getResult(I iface, getPackageInfo_args args) throws org.apache.thrift.TException { - getPackageInfo_result result = new getPackageInfo_result(); - try { - result.success = iface.getPackageInfo(args.pid); - } catch (PackageDoesNotExists e) { - result.e = e; - } - return result; - } - } + /** + * 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; + } - private static class getFileData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getFileData_args> { - public getFileData() { - super("getFileData"); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - protected getFileData_args getEmptyArgsInstance() { - return new getFileData_args(); - } + private final short _thriftId; + private final String _fieldName; - protected getFileData_result getResult(I iface, getFileData_args args) throws org.apache.thrift.TException { - getFileData_result result = new getFileData_result(); - try { - result.success = iface.getFileData(args.fid); - } catch (FileDoesNotExists e) { - result.e = e; - } - return result; - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class getQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getQueue_args> { - public getQueue() { - super("getQueue"); - } + public short getThriftFieldId() { + return _thriftId; + } - protected getQueue_args getEmptyArgsInstance() { - return new getQueue_args(); - } + public String getFieldName() { + return _fieldName; + } + } - protected getQueue_result getResult(I iface, getQueue_args args) throws org.apache.thrift.TException { - getQueue_result result = new getQueue_result(); - result.success = iface.getQueue(); - return result; - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class getCollector<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCollector_args> { - public getCollector() { - super("getCollector"); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueue_args.class, metaDataMap); + } - protected getCollector_args getEmptyArgsInstance() { - return new getCollector_args(); - } + public getQueue_args() { + } - protected getCollector_result getResult(I iface, getCollector_args args) throws org.apache.thrift.TException { - getCollector_result result = new getCollector_result(); - result.success = iface.getCollector(); - return result; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getQueue_args(getQueue_args other) { + } - private static class getQueueData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getQueueData_args> { - public getQueueData() { - super("getQueueData"); - } + public getQueue_args deepCopy() { + return new getQueue_args(this); + } - protected getQueueData_args getEmptyArgsInstance() { - return new getQueueData_args(); - } + @Override + public void clear() { + } - protected getQueueData_result getResult(I iface, getQueueData_args args) throws org.apache.thrift.TException { - getQueueData_result result = new getQueueData_result(); - result.success = iface.getQueueData(); - return result; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private static class getCollectorData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCollectorData_args> { - public getCollectorData() { - super("getCollectorData"); - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - protected getCollectorData_args getEmptyArgsInstance() { - return new getCollectorData_args(); - } + /** 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(); + } - protected getCollectorData_result getResult(I iface, getCollectorData_args args) throws org.apache.thrift.TException { - getCollectorData_result result = new getCollectorData_result(); - result.success = iface.getCollectorData(); - return result; - } - } + switch (field) { + } + throw new IllegalStateException(); + } - private static class getPackageOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getPackageOrder_args> { - public getPackageOrder() { - super("getPackageOrder"); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getQueue_args) + return this.equals((getQueue_args) that); + return false; + } - protected getPackageOrder_args getEmptyArgsInstance() { - return new getPackageOrder_args(); - } + public boolean equals(getQueue_args that) { + if (that == null) + return false; - protected getPackageOrder_result getResult(I iface, getPackageOrder_args args) throws org.apache.thrift.TException { - getPackageOrder_result result = new getPackageOrder_result(); - result.success = iface.getPackageOrder(args.destination); - return result; - } - } + return true; + } - private static class getFileOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getFileOrder_args> { - public getFileOrder() { - super("getFileOrder"); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - protected getFileOrder_args getEmptyArgsInstance() { - return new getFileOrder_args(); - } + return list.hashCode(); + } - protected getFileOrder_result getResult(I iface, getFileOrder_args args) throws org.apache.thrift.TException { - getFileOrder_result result = new getFileOrder_result(); - result.success = iface.getFileOrder(args.pid); - return result; - } - } + @Override + public int compareTo(getQueue_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class generateAndAddPackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, generateAndAddPackages_args> { - public generateAndAddPackages() { - super("generateAndAddPackages"); - } + int lastComparison = 0; - protected generateAndAddPackages_args getEmptyArgsInstance() { - return new generateAndAddPackages_args(); - } + return 0; + } - protected generateAndAddPackages_result getResult(I iface, generateAndAddPackages_args args) throws org.apache.thrift.TException { - generateAndAddPackages_result result = new generateAndAddPackages_result(); - result.success = iface.generateAndAddPackages(args.links, args.dest); - return result; - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class addPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addPackage_args> { - public addPackage() { - super("addPackage"); - } - - protected addPackage_args getEmptyArgsInstance() { - return new addPackage_args(); - } - - protected addPackage_result getResult(I iface, addPackage_args args) throws org.apache.thrift.TException { - addPackage_result result = new addPackage_result(); - result.success = iface.addPackage(args.name, args.links, args.dest); - result.setSuccessIsSet(true); - return result; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class addFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, addFiles_args> { - public addFiles() { - super("addFiles"); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - protected addFiles_args getEmptyArgsInstance() { - return new addFiles_args(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getQueue_args("); + boolean first = true; - protected addFiles_result getResult(I iface, addFiles_args args) throws org.apache.thrift.TException { - addFiles_result result = new addFiles_result(); - iface.addFiles(args.pid, args.links); - return result; - } - } + sb.append(")"); + return sb.toString(); + } - private static class uploadContainer<I extends Iface> extends org.apache.thrift.ProcessFunction<I, uploadContainer_args> { - public uploadContainer() { - super("uploadContainer"); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - protected uploadContainer_args getEmptyArgsInstance() { - return new uploadContainer_args(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - protected uploadContainer_result getResult(I iface, uploadContainer_args args) throws org.apache.thrift.TException { - uploadContainer_result result = new uploadContainer_result(); - iface.uploadContainer(args.filename, args.data); - return result; - } - } + 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 deleteFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteFiles_args> { - public deleteFiles() { - super("deleteFiles"); - } + private static class getQueue_argsStandardSchemeFactory implements SchemeFactory { + public getQueue_argsStandardScheme getScheme() { + return new getQueue_argsStandardScheme(); + } + } - protected deleteFiles_args getEmptyArgsInstance() { - return new deleteFiles_args(); - } + private static class getQueue_argsStandardScheme extends StandardScheme<getQueue_args> { - protected deleteFiles_result getResult(I iface, deleteFiles_args args) throws org.apache.thrift.TException { - deleteFiles_result result = new deleteFiles_result(); - iface.deleteFiles(args.fids); - return result; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getQueue_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(); - private static class deletePackages<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deletePackages_args> { - public deletePackages() { - super("deletePackages"); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - protected deletePackages_args getEmptyArgsInstance() { - return new deletePackages_args(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getQueue_args struct) throws org.apache.thrift.TException { + struct.validate(); - protected deletePackages_result getResult(I iface, deletePackages_args args) throws org.apache.thrift.TException { - deletePackages_result result = new deletePackages_result(); - iface.deletePackages(args.pids); - return result; - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class pushToQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pushToQueue_args> { - public pushToQueue() { - super("pushToQueue"); - } + } - protected pushToQueue_args getEmptyArgsInstance() { - return new pushToQueue_args(); - } + private static class getQueue_argsTupleSchemeFactory implements SchemeFactory { + public getQueue_argsTupleScheme getScheme() { + return new getQueue_argsTupleScheme(); + } + } - protected pushToQueue_result getResult(I iface, pushToQueue_args args) throws org.apache.thrift.TException { - pushToQueue_result result = new pushToQueue_result(); - iface.pushToQueue(args.pid); - return result; - } - } + private static class getQueue_argsTupleScheme extends TupleScheme<getQueue_args> { - private static class pullFromQueue<I extends Iface> extends org.apache.thrift.ProcessFunction<I, pullFromQueue_args> { - public pullFromQueue() { - super("pullFromQueue"); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - protected pullFromQueue_args getEmptyArgsInstance() { - return new pullFromQueue_args(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - protected pullFromQueue_result getResult(I iface, pullFromQueue_args args) throws org.apache.thrift.TException { - pullFromQueue_result result = new pullFromQueue_result(); - iface.pullFromQueue(args.pid); - return result; - } } - private static class restartPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartPackage_args> { - public restartPackage() { - super("restartPackage"); - } + public static class getQueue_result implements org.apache.thrift.TBase<getQueue_result, getQueue_result._Fields>, java.io.Serializable, Cloneable, Comparable<getQueue_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueue_result"); - protected restartPackage_args getEmptyArgsInstance() { - return new restartPackage_args(); - } + 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); - protected restartPackage_result getResult(I iface, restartPackage_args args) throws org.apache.thrift.TException { - restartPackage_result result = new restartPackage_result(); - iface.restartPackage(args.pid); - return result; - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class restartFile<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartFile_args> { - public restartFile() { - super("restartFile"); - } + static { + schemes.put(StandardScheme.class, new getQueue_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getQueue_resultTupleSchemeFactory()); + } - protected restartFile_args getEmptyArgsInstance() { - return new restartFile_args(); - } + public List<PackageData> success; // required - protected restartFile_result getResult(I iface, restartFile_args args) throws org.apache.thrift.TException { - restartFile_result result = new restartFile_result(); - iface.restartFile(args.fid); - return result; - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } - private static class recheckPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, recheckPackage_args> { - public recheckPackage() { - super("recheckPackage"); - } + @Override + public int describeContents() { + return 0; + } - protected recheckPackage_args getEmptyArgsInstance() { - return new recheckPackage_args(); - } + public getQueue_result(android.os.Parcel in) { + this.success = new ArrayList<PackageData>(); + in.readTypedList(this.success, PackageData.CREATOR); + } - protected recheckPackage_result getResult(I iface, recheckPackage_args args) throws org.apache.thrift.TException { - recheckPackage_result result = new recheckPackage_result(); - iface.recheckPackage(args.pid); - return result; - } - } + public static final android.os.Parcelable.Creator<getQueue_result> CREATOR = new android.os.Parcelable.Creator<getQueue_result>() { + @Override + public getQueue_result[] newArray(int size) { + return new getQueue_result[size]; + } - private static class stopAllDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, stopAllDownloads_args> { - public stopAllDownloads() { - super("stopAllDownloads"); - } + @Override + public getQueue_result createFromParcel(android.os.Parcel in) { + return new getQueue_result(in); + } + }; - protected stopAllDownloads_args getEmptyArgsInstance() { - return new stopAllDownloads_args(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + SUCCESS((short) 0, "success"); - protected stopAllDownloads_result getResult(I iface, stopAllDownloads_args args) throws org.apache.thrift.TException { - stopAllDownloads_result result = new stopAllDownloads_result(); - iface.stopAllDownloads(); - return result; - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class stopDownloads<I extends Iface> extends org.apache.thrift.ProcessFunction<I, stopDownloads_args> { - public stopDownloads() { - super("stopDownloads"); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - protected stopDownloads_args getEmptyArgsInstance() { - return new stopDownloads_args(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - protected stopDownloads_result getResult(I iface, stopDownloads_args args) throws org.apache.thrift.TException { - stopDownloads_result result = new stopDownloads_result(); - iface.stopDownloads(args.fids); - return result; - } - } + /** + * 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; + } - private static class setPackageName<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setPackageName_args> { - public setPackageName() { - super("setPackageName"); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - protected setPackageName_args getEmptyArgsInstance() { - return new setPackageName_args(); - } + private final short _thriftId; + private final String _fieldName; - protected setPackageName_result getResult(I iface, setPackageName_args args) throws org.apache.thrift.TException { - setPackageName_result result = new setPackageName_result(); - iface.setPackageName(args.pid, args.name); - return result; - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class movePackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, movePackage_args> { - public movePackage() { - super("movePackage"); - } + public short getThriftFieldId() { + return _thriftId; + } - protected movePackage_args getEmptyArgsInstance() { - return new movePackage_args(); - } + public String getFieldName() { + return _fieldName; + } + } - protected movePackage_result getResult(I iface, movePackage_args args) throws org.apache.thrift.TException { - movePackage_result result = new movePackage_result(); - iface.movePackage(args.destination, args.pid); - return result; - } - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class moveFiles<I extends Iface> extends org.apache.thrift.ProcessFunction<I, moveFiles_args> { - public moveFiles() { - super("moveFiles"); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueue_result.class, metaDataMap); + } - protected moveFiles_args getEmptyArgsInstance() { - return new moveFiles_args(); - } + public getQueue_result() { + } - protected moveFiles_result getResult(I iface, moveFiles_args args) throws org.apache.thrift.TException { - moveFiles_result result = new moveFiles_result(); - iface.moveFiles(args.fids, args.pid); - return result; - } - } + public getQueue_result( + List<PackageData> success) { + this(); + this.success = success; + } - private static class orderPackage<I extends Iface> extends org.apache.thrift.ProcessFunction<I, orderPackage_args> { - public orderPackage() { - super("orderPackage"); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getQueue_result(getQueue_result other) { + if (other.isSetSuccess()) { + List<PackageData> __this__success = new ArrayList<PackageData>(other.success.size()); + for (PackageData other_element : other.success) { + __this__success.add(new PackageData(other_element)); + } + this.success = __this__success; + } + } - protected orderPackage_args getEmptyArgsInstance() { - return new orderPackage_args(); - } + public getQueue_result deepCopy() { + return new getQueue_result(this); + } - protected orderPackage_result getResult(I iface, orderPackage_args args) throws org.apache.thrift.TException { - orderPackage_result result = new orderPackage_result(); - iface.orderPackage(args.pid, args.position); - return result; - } - } + @Override + public void clear() { + this.success = null; + } - private static class orderFile<I extends Iface> extends org.apache.thrift.ProcessFunction<I, orderFile_args> { - public orderFile() { - super("orderFile"); - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - protected orderFile_args getEmptyArgsInstance() { - return new orderFile_args(); - } + public java.util.Iterator<PackageData> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - protected orderFile_result getResult(I iface, orderFile_args args) throws org.apache.thrift.TException { - orderFile_result result = new orderFile_result(); - iface.orderFile(args.fid, args.position); - return result; - } - } + public void addToSuccess(PackageData elem) { + if (this.success == null) { + this.success = new ArrayList<PackageData>(); + } + this.success.add(elem); + } - private static class setPackageData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setPackageData_args> { - public setPackageData() { - super("setPackageData"); - } + public List<PackageData> getSuccess() { + return this.success; + } - protected setPackageData_args getEmptyArgsInstance() { - return new setPackageData_args(); - } + public getQueue_result setSuccess(List<PackageData> success) { + this.success = success; + return this; + } - protected setPackageData_result getResult(I iface, setPackageData_args args) throws org.apache.thrift.TException { - setPackageData_result result = new setPackageData_result(); - try { - iface.setPackageData(args.pid, args.data); - } catch (PackageDoesNotExists e) { - result.e = e; + public void unsetSuccess() { + this.success = null; } - return result; - } - } - private static class deleteFinished<I extends Iface> extends org.apache.thrift.ProcessFunction<I, deleteFinished_args> { - public deleteFinished() { - super("deleteFinished"); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - protected deleteFinished_args getEmptyArgsInstance() { - return new deleteFinished_args(); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - protected deleteFinished_result getResult(I iface, deleteFinished_args args) throws org.apache.thrift.TException { - deleteFinished_result result = new deleteFinished_result(); - result.success = iface.deleteFinished(); - return result; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<PackageData>) value); + } + break; - private static class restartFailed<I extends Iface> extends org.apache.thrift.ProcessFunction<I, restartFailed_args> { - public restartFailed() { - super("restartFailed"); - } + } + } - protected restartFailed_args getEmptyArgsInstance() { - return new restartFailed_args(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - protected restartFailed_result getResult(I iface, restartFailed_args args) throws org.apache.thrift.TException { - restartFailed_result result = new restartFailed_result(); - iface.restartFailed(); - return result; - } - } + } + throw new IllegalStateException(); + } - private static class isCaptchaWaiting<I extends Iface> extends org.apache.thrift.ProcessFunction<I, isCaptchaWaiting_args> { - public isCaptchaWaiting() { - super("isCaptchaWaiting"); - } - - protected isCaptchaWaiting_args getEmptyArgsInstance() { - return new isCaptchaWaiting_args(); - } - - protected isCaptchaWaiting_result getResult(I iface, isCaptchaWaiting_args args) throws org.apache.thrift.TException { - isCaptchaWaiting_result result = new isCaptchaWaiting_result(); - result.success = iface.isCaptchaWaiting(); - result.setSuccessIsSet(true); - return result; - } - } + /** 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(); + } - private static class getCaptchaTask<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCaptchaTask_args> { - public getCaptchaTask() { - super("getCaptchaTask"); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - protected getCaptchaTask_args getEmptyArgsInstance() { - return new getCaptchaTask_args(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getQueue_result) + return this.equals((getQueue_result) that); + return false; + } - protected getCaptchaTask_result getResult(I iface, getCaptchaTask_args args) throws org.apache.thrift.TException { - getCaptchaTask_result result = new getCaptchaTask_result(); - result.success = iface.getCaptchaTask(args.exclusive); - return result; - } - } + public boolean equals(getQueue_result that) { + if (that == null) + return false; - private static class getCaptchaTaskStatus<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getCaptchaTaskStatus_args> { - public getCaptchaTaskStatus() { - super("getCaptchaTaskStatus"); - } + 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; + } - protected getCaptchaTaskStatus_args getEmptyArgsInstance() { - return new getCaptchaTaskStatus_args(); - } + return true; + } - protected getCaptchaTaskStatus_result getResult(I iface, getCaptchaTaskStatus_args args) throws org.apache.thrift.TException { - getCaptchaTaskStatus_result result = new getCaptchaTaskStatus_result(); - result.success = iface.getCaptchaTaskStatus(args.tid); - return result; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class setCaptchaResult<I extends Iface> extends org.apache.thrift.ProcessFunction<I, setCaptchaResult_args> { - public setCaptchaResult() { - super("setCaptchaResult"); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - protected setCaptchaResult_args getEmptyArgsInstance() { - return new setCaptchaResult_args(); - } + return list.hashCode(); + } - protected setCaptchaResult_result getResult(I iface, setCaptchaResult_args args) throws org.apache.thrift.TException { - setCaptchaResult_result result = new setCaptchaResult_result(); - iface.setCaptchaResult(args.tid, args.result); - return result; - } - } + @Override + public int compareTo(getQueue_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class getEvents<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getEvents_args> { - public getEvents() { - super("getEvents"); - } + int lastComparison = 0; - protected getEvents_args getEmptyArgsInstance() { - return new getEvents_args(); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - protected getEvents_result getResult(I iface, getEvents_args args) throws org.apache.thrift.TException { - getEvents_result result = new getEvents_result(); - result.success = iface.getEvents(args.uuid); - return result; - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class getAccounts<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAccounts_args> { - public getAccounts() { - super("getAccounts"); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - protected getAccounts_args getEmptyArgsInstance() { - return new getAccounts_args(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - protected getAccounts_result getResult(I iface, getAccounts_args args) throws org.apache.thrift.TException { - getAccounts_result result = new getAccounts_result(); - result.success = iface.getAccounts(args.refresh); - return result; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getQueue_result("); + boolean first = true; - private static class getAccountTypes<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAccountTypes_args> { - public getAccountTypes() { - super("getAccountTypes"); - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - protected getAccountTypes_args getEmptyArgsInstance() { - return new getAccountTypes_args(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - protected getAccountTypes_result getResult(I iface, getAccountTypes_args args) throws org.apache.thrift.TException { - getAccountTypes_result result = new getAccountTypes_result(); - result.success = iface.getAccountTypes(); - return result; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class updateAccount<I extends Iface> extends org.apache.thrift.ProcessFunction<I, updateAccount_args> { - public updateAccount() { - super("updateAccount"); - } + 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); + } + } - protected updateAccount_args getEmptyArgsInstance() { - return new updateAccount_args(); - } + private static class getQueue_resultStandardSchemeFactory implements SchemeFactory { + public getQueue_resultStandardScheme getScheme() { + return new getQueue_resultStandardScheme(); + } + } - protected updateAccount_result getResult(I iface, updateAccount_args args) throws org.apache.thrift.TException { - updateAccount_result result = new updateAccount_result(); - iface.updateAccount(args.plugin, args.account, args.password, args.options); - return result; - } - } + private static class getQueue_resultStandardScheme extends StandardScheme<getQueue_result> { - private static class removeAccount<I extends Iface> extends org.apache.thrift.ProcessFunction<I, removeAccount_args> { - public removeAccount() { - super("removeAccount"); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getQueue_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 _list206 = iprot.readListBegin(); + struct.success = new ArrayList<PackageData>(_list206.size); + PackageData _elem207; + for (int _i208 = 0; _i208 < _list206.size; ++_i208) { + _elem207 = new PackageData(); + _elem207.read(iprot); + struct.success.add(_elem207); + } + iprot.readListEnd(); + } + 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(); - protected removeAccount_args getEmptyArgsInstance() { - return new removeAccount_args(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - protected removeAccount_result getResult(I iface, removeAccount_args args) throws org.apache.thrift.TException { - removeAccount_result result = new removeAccount_result(); - iface.removeAccount(args.plugin, args.account); - return result; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getQueue_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class login<I extends Iface> extends org.apache.thrift.ProcessFunction<I, login_args> { - public login() { - super("login"); - } - - protected login_args getEmptyArgsInstance() { - return new login_args(); - } - - protected login_result getResult(I iface, login_args args) throws org.apache.thrift.TException { - login_result result = new login_result(); - result.success = iface.login(args.username, args.password); - result.setSuccessIsSet(true); - return result; - } - } + 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 (PackageData _iter209 : struct.success) { + _iter209.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class getUserData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getUserData_args> { - public getUserData() { - super("getUserData"); - } + } - protected getUserData_args getEmptyArgsInstance() { - return new getUserData_args(); - } + private static class getQueue_resultTupleSchemeFactory implements SchemeFactory { + public getQueue_resultTupleScheme getScheme() { + return new getQueue_resultTupleScheme(); + } + } - protected getUserData_result getResult(I iface, getUserData_args args) throws org.apache.thrift.TException { - getUserData_result result = new getUserData_result(); - result.success = iface.getUserData(args.username, args.password); - return result; - } - } + private static class getQueue_resultTupleScheme extends TupleScheme<getQueue_result> { - private static class getAllUserData<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllUserData_args> { - public getAllUserData() { - super("getAllUserData"); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (PackageData _iter210 : struct.success) { + _iter210.write(oprot); + } + } + } + } - protected getAllUserData_args getEmptyArgsInstance() { - return new getAllUserData_args(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list211 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<PackageData>(_list211.size); + PackageData _elem212; + for (int _i213 = 0; _i213 < _list211.size; ++_i213) { + _elem212 = new PackageData(); + _elem212.read(iprot); + struct.success.add(_elem212); + } + } + struct.setSuccessIsSet(true); + } + } + } - protected getAllUserData_result getResult(I iface, getAllUserData_args args) throws org.apache.thrift.TException { - getAllUserData_result result = new getAllUserData_result(); - result.success = iface.getAllUserData(); - return result; - } } - private static class getServices<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getServices_args> { - public getServices() { - super("getServices"); - } + public static class getCollector_args implements org.apache.thrift.TBase<getCollector_args, getCollector_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCollector_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollector_args"); - protected getServices_args getEmptyArgsInstance() { - return new getServices_args(); - } - protected getServices_result getResult(I iface, getServices_args args) throws org.apache.thrift.TException { - getServices_result result = new getServices_result(); - result.success = iface.getServices(); - return result; - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class hasService<I extends Iface> extends org.apache.thrift.ProcessFunction<I, hasService_args> { - public hasService() { - super("hasService"); - } - - protected hasService_args getEmptyArgsInstance() { - return new hasService_args(); - } - - protected hasService_result getResult(I iface, hasService_args args) throws org.apache.thrift.TException { - hasService_result result = new hasService_result(); - result.success = iface.hasService(args.plugin, args.func); - result.setSuccessIsSet(true); - return result; - } - } + static { + schemes.put(StandardScheme.class, new getCollector_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCollector_argsTupleSchemeFactory()); + } - private static class call<I extends Iface> extends org.apache.thrift.ProcessFunction<I, call_args> { - public call() { - super("call"); - } - - protected call_args getEmptyArgsInstance() { - return new call_args(); - } - - protected call_result getResult(I iface, call_args args) throws org.apache.thrift.TException { - call_result result = new call_result(); - try { - result.success = iface.call(args.info); - } catch (ServiceDoesNotExists ex) { - result.ex = ex; - } catch (ServiceException e) { - result.e = e; - } - return result; - } - } - private static class getAllInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllInfo_args> { - public getAllInfo() { - super("getAllInfo"); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } + + @Override + public int describeContents() { + return 0; + } - protected getAllInfo_args getEmptyArgsInstance() { - return new getAllInfo_args(); - } + public getCollector_args(android.os.Parcel in) { + } - protected getAllInfo_result getResult(I iface, getAllInfo_args args) throws org.apache.thrift.TException { - getAllInfo_result result = new getAllInfo_result(); - result.success = iface.getAllInfo(); - return result; - } - } + public static final android.os.Parcelable.Creator<getCollector_args> CREATOR = new android.os.Parcelable.Creator<getCollector_args>() { + @Override + public getCollector_args[] newArray(int size) { + return new getCollector_args[size]; + } - private static class getInfoByPlugin<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getInfoByPlugin_args> { - public getInfoByPlugin() { - super("getInfoByPlugin"); - } + @Override + public getCollector_args createFromParcel(android.os.Parcel in) { + return new getCollector_args(in); + } + }; - protected getInfoByPlugin_args getEmptyArgsInstance() { - return new getInfoByPlugin_args(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - protected getInfoByPlugin_result getResult(I iface, getInfoByPlugin_args args) throws org.apache.thrift.TException { - getInfoByPlugin_result result = new getInfoByPlugin_result(); - result.success = iface.getInfoByPlugin(args.plugin); - return result; - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public static class getConfigValue_args implements org.apache.thrift.TBase<getConfigValue_args, getConfigValue_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfigValue_args"); + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static final org.apache.thrift.protocol.TField CATEGORY_FIELD_DESC = new org.apache.thrift.protocol.TField("category", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField OPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("option", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField SECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("section", org.apache.thrift.protocol.TType.STRING, (short)3); + /** + * 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; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getConfigValue_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getConfigValue_argsTupleSchemeFactory()); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public String category; // required - public String option; // required - public String section; // 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 { - CATEGORY((short)1, "category"), - OPTION((short)2, "option"), - SECTION((short)3, "section"); - - 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: // CATEGORY - return CATEGORY; - case 2: // OPTION - return OPTION; - case 3: // SECTION - return SECTION; - 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; - } - } + private final short _thriftId; + private final String _fieldName; - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.CATEGORY, new org.apache.thrift.meta_data.FieldMetaData("category", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.OPTION, new org.apache.thrift.meta_data.FieldMetaData("option", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.SECTION, new org.apache.thrift.meta_data.FieldMetaData("section", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfigValue_args.class, metaDataMap); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public getConfigValue_args() { - } + public short getThriftFieldId() { + return _thriftId; + } - public getConfigValue_args( - String category, - String option, - String section) - { - this(); - this.category = category; - this.option = option; - this.section = section; - } + public String getFieldName() { + return _fieldName; + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getConfigValue_args(getConfigValue_args other) { - if (other.isSetCategory()) { - this.category = other.category; - } - if (other.isSetOption()) { - this.option = other.option; - } - if (other.isSetSection()) { - this.section = other.section; - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public getConfigValue_args deepCopy() { - return new getConfigValue_args(this); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollector_args.class, metaDataMap); + } - @Override - public void clear() { - this.category = null; - this.option = null; - this.section = null; - } + public getCollector_args() { + } - public String getCategory() { - return this.category; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getCollector_args(getCollector_args other) { + } - public getConfigValue_args setCategory(String category) { - this.category = category; - return this; - } + public getCollector_args deepCopy() { + return new getCollector_args(this); + } - public void unsetCategory() { - this.category = null; - } + @Override + public void clear() { + } - /** Returns true if field category is set (has been assigned a value) and false otherwise */ - public boolean isSetCategory() { - return this.category != null; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public void setCategoryIsSet(boolean value) { - if (!value) { - this.category = null; - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public String getOption() { - return this.option; - } + /** 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(); + } - public getConfigValue_args setOption(String option) { - this.option = option; - return this; - } + switch (field) { + } + throw new IllegalStateException(); + } - public void unsetOption() { - this.option = null; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCollector_args) + return this.equals((getCollector_args) that); + return false; + } - /** Returns true if field option is set (has been assigned a value) and false otherwise */ - public boolean isSetOption() { - return this.option != null; - } + public boolean equals(getCollector_args that) { + if (that == null) + return false; - public void setOptionIsSet(boolean value) { - if (!value) { - this.option = null; - } - } + return true; + } - public String getSection() { - return this.section; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public getConfigValue_args setSection(String section) { - this.section = section; - return this; - } + return list.hashCode(); + } - public void unsetSection() { - this.section = null; - } + @Override + public int compareTo(getCollector_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - /** Returns true if field section is set (has been assigned a value) and false otherwise */ - public boolean isSetSection() { - return this.section != null; - } + int lastComparison = 0; - public void setSectionIsSet(boolean value) { - if (!value) { - this.section = null; - } - } + return 0; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case CATEGORY: - if (value == null) { - unsetCategory(); - } else { - setCategory((String)value); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - break; - case OPTION: - if (value == null) { - unsetOption(); - } else { - setOption((String)value); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - break; - case SECTION: - if (value == null) { - unsetSection(); - } else { - setSection((String)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCollector_args("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case CATEGORY: - return getCategory(); + sb.append(")"); + return sb.toString(); + } - case OPTION: - return getOption(); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - case SECTION: - return getSection(); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - } - throw new IllegalStateException(); - } + 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); + } + } - /** 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 CATEGORY: - return isSetCategory(); - case OPTION: - return isSetOption(); - case SECTION: - return isSetSection(); - } - throw new IllegalStateException(); - } + private static class getCollector_argsStandardSchemeFactory implements SchemeFactory { + public getCollector_argsStandardScheme getScheme() { + return new getCollector_argsStandardScheme(); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getConfigValue_args) - return this.equals((getConfigValue_args)that); - return false; - } + private static class getCollector_argsStandardScheme extends StandardScheme<getCollector_args> { - public boolean equals(getConfigValue_args that) { - if (that == null) - return false; - - boolean this_present_category = true && this.isSetCategory(); - boolean that_present_category = true && that.isSetCategory(); - if (this_present_category || that_present_category) { - if (!(this_present_category && that_present_category)) - return false; - if (!this.category.equals(that.category)) - return false; - } - - boolean this_present_option = true && this.isSetOption(); - boolean that_present_option = true && that.isSetOption(); - if (this_present_option || that_present_option) { - if (!(this_present_option && that_present_option)) - return false; - if (!this.option.equals(that.option)) - return false; - } - - boolean this_present_section = true && this.isSetSection(); - boolean that_present_section = true && that.isSetSection(); - if (this_present_section || that_present_section) { - if (!(this_present_section && that_present_section)) - return false; - if (!this.section.equals(that.section)) - return false; - } - - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCollector_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(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(getConfigValue_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getConfigValue_args typedOther = (getConfigValue_args)other; - - lastComparison = Boolean.valueOf(isSetCategory()).compareTo(typedOther.isSetCategory()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetCategory()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.category, typedOther.category); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOption()).compareTo(typedOther.isSetOption()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOption()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.option, typedOther.option); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSection()).compareTo(typedOther.isSetSection()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSection()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.section, typedOther.section); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCollector_args struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class getCollector_argsTupleSchemeFactory implements SchemeFactory { + public getCollector_argsTupleScheme getScheme() { + return new getCollector_argsTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getConfigValue_args("); - boolean first = true; - - sb.append("category:"); - if (this.category == null) { - sb.append("null"); - } else { - sb.append(this.category); - } - first = false; - if (!first) sb.append(", "); - sb.append("option:"); - if (this.option == null) { - sb.append("null"); - } else { - sb.append(this.option); - } - first = false; - if (!first) sb.append(", "); - sb.append("section:"); - if (this.section == null) { - sb.append("null"); - } else { - sb.append(this.section); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private static class getCollector_argsTupleScheme extends TupleScheme<getCollector_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCollector_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCollector_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - 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.getMessage()); - } } - private static class getConfigValue_argsStandardSchemeFactory implements SchemeFactory { - public getConfigValue_argsStandardScheme getScheme() { - return new getConfigValue_argsStandardScheme(); - } - } + public static class getCollector_result implements org.apache.thrift.TBase<getCollector_result, getCollector_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCollector_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollector_result"); - private static class getConfigValue_argsStandardScheme extends StandardScheme<getConfigValue_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getConfigValue_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: // CATEGORY - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.category = iprot.readString(); - struct.setCategoryIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // OPTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.option = iprot.readString(); - struct.setOptionIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 3: // SECTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.section = iprot.readString(); - struct.setSectionIsSet(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, getConfigValue_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.category != null) { - oprot.writeFieldBegin(CATEGORY_FIELD_DESC); - oprot.writeString(struct.category); - oprot.writeFieldEnd(); - } - if (struct.option != null) { - oprot.writeFieldBegin(OPTION_FIELD_DESC); - oprot.writeString(struct.option); - oprot.writeFieldEnd(); - } - if (struct.section != null) { - oprot.writeFieldBegin(SECTION_FIELD_DESC); - oprot.writeString(struct.section); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class getConfigValue_argsTupleSchemeFactory implements SchemeFactory { - public getConfigValue_argsTupleScheme getScheme() { - return new getConfigValue_argsTupleScheme(); - } - } + static { + schemes.put(StandardScheme.class, new getCollector_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCollector_resultTupleSchemeFactory()); + } - private static class getConfigValue_argsTupleScheme extends TupleScheme<getConfigValue_args> { + public List<PackageData> success; // required - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getConfigValue_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetCategory()) { - optionals.set(0); - } - if (struct.isSetOption()) { - optionals.set(1); - } - if (struct.isSetSection()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); - if (struct.isSetCategory()) { - oprot.writeString(struct.category); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); } - if (struct.isSetOption()) { - oprot.writeString(struct.option); - } - if (struct.isSetSection()) { - oprot.writeString(struct.section); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getConfigValue_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); - if (incoming.get(0)) { - struct.category = iprot.readString(); - struct.setCategoryIsSet(true); - } - if (incoming.get(1)) { - struct.option = iprot.readString(); - struct.setOptionIsSet(true); - } - if (incoming.get(2)) { - struct.section = iprot.readString(); - struct.setSectionIsSet(true); + @Override + public int describeContents() { + return 0; } - } - } - - } - - public static class getConfigValue_result implements org.apache.thrift.TBase<getConfigValue_result, getConfigValue_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfigValue_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getConfigValue_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getConfigValue_resultTupleSchemeFactory()); - } - - public 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 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 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 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; - } - } + public getCollector_result(android.os.Parcel in) { + this.success = new ArrayList<PackageData>(); + in.readTypedList(this.success, PackageData.CREATOR); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfigValue_result.class, metaDataMap); - } + public static final android.os.Parcelable.Creator<getCollector_result> CREATOR = new android.os.Parcelable.Creator<getCollector_result>() { + @Override + public getCollector_result[] newArray(int size) { + return new getCollector_result[size]; + } - public getConfigValue_result() { - } + @Override + public getCollector_result createFromParcel(android.os.Parcel in) { + return new getCollector_result(in); + } + }; - public getConfigValue_result( - String success) - { - this(); - this.success = success; - } + /** 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"); - /** - * Performs a deep copy on <i>other</i>. - */ - public getConfigValue_result(getConfigValue_result other) { - if (other.isSetSuccess()) { - this.success = other.success; - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public getConfigValue_result deepCopy() { - return new getConfigValue_result(this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void clear() { - this.success = null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public String getSuccess() { - return this.success; - } + /** + * 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; + } - public getConfigValue_result setSuccess(String success) { - this.success = success; - return this; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void unsetSuccess() { - this.success = null; - } + private final short _thriftId; + private final String _fieldName; - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public short getThriftFieldId() { + return _thriftId; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((String)value); + public String getFieldName() { + return _fieldName; + } } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollector_result.class, metaDataMap); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public getCollector_result() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getConfigValue_result) - return this.equals((getConfigValue_result)that); - return false; - } + public getCollector_result( + List<PackageData> success) { + this(); + this.success = success; + } - public boolean equals(getConfigValue_result that) { - if (that == null) - return false; + /** + * Performs a deep copy on <i>other</i>. + */ + public getCollector_result(getCollector_result other) { + if (other.isSetSuccess()) { + List<PackageData> __this__success = new ArrayList<PackageData>(other.success.size()); + for (PackageData other_element : other.success) { + __this__success.add(new PackageData(other_element)); + } + this.success = __this__success; + } + } - 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; - } + public getCollector_result deepCopy() { + return new getCollector_result(this); + } - return true; - } + @Override + public void clear() { + this.success = null; + } - @Override - public int hashCode() { - return 0; - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - public int compareTo(getConfigValue_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getConfigValue_result typedOther = (getConfigValue_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public java.util.Iterator<PackageData> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void addToSuccess(PackageData elem) { + if (this.success == null) { + this.success = new ArrayList<PackageData>(); + } + this.success.add(elem); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public List<PackageData> getSuccess() { + return this.success; + } - 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("getConfigValue_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 getCollector_result setSuccess(List<PackageData> success) { + this.success = success; + return this; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void unsetSuccess() { + this.success = null; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - 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.getMessage()); - } - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - private static class getConfigValue_resultStandardSchemeFactory implements SchemeFactory { - public getConfigValue_resultStandardScheme getScheme() { - return new getConfigValue_resultStandardScheme(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<PackageData>) value); + } + break; - private static class getConfigValue_resultStandardScheme extends StandardScheme<getConfigValue_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getConfigValue_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, getConfigValue_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(); - } + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - private static class getConfigValue_resultTupleSchemeFactory implements SchemeFactory { - public getConfigValue_resultTupleScheme getScheme() { - return new getConfigValue_resultTupleScheme(); - } - } + } + throw new IllegalStateException(); + } - private static class getConfigValue_resultTupleScheme extends TupleScheme<getConfigValue_result> { + /** 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(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getConfigValue_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeString(struct.success); + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getConfigValue_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readString(); - struct.setSuccessIsSet(true); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCollector_result) + return this.equals((getCollector_result) that); + return false; } - } - } - } + public boolean equals(getCollector_result that) { + if (that == null) + return false; - public static class setConfigValue_args implements org.apache.thrift.TBase<setConfigValue_args, setConfigValue_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setConfigValue_args"); + 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; + } - private static final org.apache.thrift.protocol.TField CATEGORY_FIELD_DESC = new org.apache.thrift.protocol.TField("category", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField OPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("option", 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 SECTION_FIELD_DESC = new org.apache.thrift.protocol.TField("section", org.apache.thrift.protocol.TType.STRING, (short)4); + return true; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setConfigValue_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setConfigValue_argsTupleSchemeFactory()); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public String category; // required - public String option; // required - public String value; // required - public String section; // 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 { - CATEGORY((short)1, "category"), - OPTION((short)2, "option"), - VALUE((short)3, "value"), - SECTION((short)4, "section"); - - 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: // CATEGORY - return CATEGORY; - case 2: // OPTION - return OPTION; - case 3: // VALUE - return VALUE; - case 4: // SECTION - return SECTION; - 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; - } - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.CATEGORY, new org.apache.thrift.meta_data.FieldMetaData("category", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.OPTION, new org.apache.thrift.meta_data.FieldMetaData("option", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - 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))); - tmpMap.put(_Fields.SECTION, new org.apache.thrift.meta_data.FieldMetaData("section", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setConfigValue_args.class, metaDataMap); - } + return list.hashCode(); + } - public setConfigValue_args() { - } + @Override + public int compareTo(getCollector_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public setConfigValue_args( - String category, - String option, - String value, - String section) - { - this(); - this.category = category; - this.option = option; - this.value = value; - this.section = section; - } + int lastComparison = 0; - /** - * Performs a deep copy on <i>other</i>. - */ - public setConfigValue_args(setConfigValue_args other) { - if (other.isSetCategory()) { - this.category = other.category; - } - if (other.isSetOption()) { - this.option = other.option; - } - if (other.isSetValue()) { - this.value = other.value; - } - if (other.isSetSection()) { - this.section = other.section; - } - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public setConfigValue_args deepCopy() { - return new setConfigValue_args(this); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public void clear() { - this.category = null; - this.option = null; - this.value = null; - this.section = null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public String getCategory() { - return this.category; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public setConfigValue_args setCategory(String category) { - this.category = category; - return this; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCollector_result("); + boolean first = true; - public void unsetCategory() { - this.category = null; - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - /** Returns true if field category is set (has been assigned a value) and false otherwise */ - public boolean isSetCategory() { - return this.category != null; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void setCategoryIsSet(boolean value) { - if (!value) { - this.category = null; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public String getOption() { - return this.option; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public setConfigValue_args setOption(String option) { - this.option = option; - return this; - } + private static class getCollector_resultStandardSchemeFactory implements SchemeFactory { + public getCollector_resultStandardScheme getScheme() { + return new getCollector_resultStandardScheme(); + } + } - public void unsetOption() { - this.option = null; - } + private static class getCollector_resultStandardScheme extends StandardScheme<getCollector_result> { - /** Returns true if field option is set (has been assigned a value) and false otherwise */ - public boolean isSetOption() { - return this.option != null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCollector_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 ArrayList<PackageData>(_list214.size); + PackageData _elem215; + for (int _i216 = 0; _i216 < _list214.size; ++_i216) { + _elem215 = new PackageData(); + _elem215.read(iprot); + struct.success.add(_elem215); + } + iprot.readListEnd(); + } + 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(); - public void setOptionIsSet(boolean value) { - if (!value) { - this.option = null; - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public String getValue() { - return this.value; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCollector_result struct) throws org.apache.thrift.TException { + struct.validate(); - public setConfigValue_args setValue(String value) { - this.value = value; - return this; - } + 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 (PackageData _iter217 : struct.success) { + _iter217.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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; - } + private static class getCollector_resultTupleSchemeFactory implements SchemeFactory { + public getCollector_resultTupleScheme getScheme() { + return new getCollector_resultTupleScheme(); + } + } - public void setValueIsSet(boolean value) { - if (!value) { - this.value = null; - } - } + private static class getCollector_resultTupleScheme extends TupleScheme<getCollector_result> { - public String getSection() { - return this.section; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCollector_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (PackageData _iter218 : struct.success) { + _iter218.write(oprot); + } + } + } + } - public setConfigValue_args setSection(String section) { - this.section = section; - return this; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCollector_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list219 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<PackageData>(_list219.size); + PackageData _elem220; + for (int _i221 = 0; _i221 < _list219.size; ++_i221) { + _elem220 = new PackageData(); + _elem220.read(iprot); + struct.success.add(_elem220); + } + } + struct.setSuccessIsSet(true); + } + } + } - public void unsetSection() { - this.section = null; } - /** Returns true if field section is set (has been assigned a value) and false otherwise */ - public boolean isSetSection() { - return this.section != null; - } + public static class getQueueData_args implements org.apache.thrift.TBase<getQueueData_args, getQueueData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getQueueData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueueData_args"); - public void setSectionIsSet(boolean value) { - if (!value) { - this.section = null; - } - } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case CATEGORY: - if (value == null) { - unsetCategory(); - } else { - setCategory((String)value); - } - break; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - case OPTION: - if (value == null) { - unsetOption(); - } else { - setOption((String)value); + static { + schemes.put(StandardScheme.class, new getQueueData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getQueueData_argsTupleSchemeFactory()); } - break; - case VALUE: - if (value == null) { - unsetValue(); - } else { - setValue((String)value); + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - break; - case SECTION: - if (value == null) { - unsetSection(); - } else { - setSection((String)value); + @Override + public int describeContents() { + return 0; } - break; - } - } + public getQueueData_args(android.os.Parcel in) { + } - public Object getFieldValue(_Fields field) { - switch (field) { - case CATEGORY: - return getCategory(); + public static final android.os.Parcelable.Creator<getQueueData_args> CREATOR = new android.os.Parcelable.Creator<getQueueData_args>() { + @Override + public getQueueData_args[] newArray(int size) { + return new getQueueData_args[size]; + } - case OPTION: - return getOption(); + @Override + public getQueueData_args createFromParcel(android.os.Parcel in) { + return new getQueueData_args(in); + } + }; - case VALUE: - return getValue(); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - case SECTION: - return getSection(); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - } - throw new IllegalStateException(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** 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 CATEGORY: - return isSetCategory(); - case OPTION: - return isSetOption(); - case VALUE: - return isSetValue(); - case SECTION: - return isSetSection(); - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setConfigValue_args) - return this.equals((setConfigValue_args)that); - return false; - } + /** + * 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; + } - public boolean equals(setConfigValue_args that) { - if (that == null) - return false; - - boolean this_present_category = true && this.isSetCategory(); - boolean that_present_category = true && that.isSetCategory(); - if (this_present_category || that_present_category) { - if (!(this_present_category && that_present_category)) - return false; - if (!this.category.equals(that.category)) - return false; - } - - boolean this_present_option = true && this.isSetOption(); - boolean that_present_option = true && that.isSetOption(); - if (this_present_option || that_present_option) { - if (!(this_present_option && that_present_option)) - return false; - if (!this.option.equals(that.option)) - 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_section = true && this.isSetSection(); - boolean that_present_section = true && that.isSetSection(); - if (this_present_section || that_present_section) { - if (!(this_present_section && that_present_section)) - return false; - if (!this.section.equals(that.section)) - return false; - } - - return true; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public int hashCode() { - return 0; - } + private final short _thriftId; + private final String _fieldName; - public int compareTo(setConfigValue_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - setConfigValue_args typedOther = (setConfigValue_args)other; - - lastComparison = Boolean.valueOf(isSetCategory()).compareTo(typedOther.isSetCategory()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetCategory()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.category, typedOther.category); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOption()).compareTo(typedOther.isSetOption()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOption()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.option, typedOther.option); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetValue()).compareTo(typedOther.isSetValue()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetValue()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.value, typedOther.value); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSection()).compareTo(typedOther.isSetSection()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSection()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.section, typedOther.section); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public short getThriftFieldId() { + return _thriftId; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public String getFieldName() { + return _fieldName; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setConfigValue_args("); - boolean first = true; - - sb.append("category:"); - if (this.category == null) { - sb.append("null"); - } else { - sb.append(this.category); - } - first = false; - if (!first) sb.append(", "); - sb.append("option:"); - if (this.option == null) { - sb.append("null"); - } else { - sb.append(this.option); - } - first = false; - if (!first) sb.append(", "); - sb.append("value:"); - if (this.value == null) { - sb.append("null"); - } else { - sb.append(this.value); - } - first = false; - if (!first) sb.append(", "); - sb.append("section:"); - if (this.section == null) { - sb.append("null"); - } else { - sb.append(this.section); - } - first = false; - sb.append(")"); - return sb.toString(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueueData_args.class, metaDataMap); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public getQueueData_args() { + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getQueueData_args(getQueueData_args other) { + } - 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.getMessage()); - } - } + public getQueueData_args deepCopy() { + return new getQueueData_args(this); + } - private static class setConfigValue_argsStandardSchemeFactory implements SchemeFactory { - public setConfigValue_argsStandardScheme getScheme() { - return new setConfigValue_argsStandardScheme(); - } - } + @Override + public void clear() { + } - private static class setConfigValue_argsStandardScheme extends StandardScheme<setConfigValue_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setConfigValue_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: // CATEGORY - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.category = iprot.readString(); - struct.setCategoryIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // OPTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.option = iprot.readString(); - struct.setOptionIsSet(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.readString(); - struct.setValueIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 4: // SECTION - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.section = iprot.readString(); - struct.setSectionIsSet(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, setConfigValue_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.category != null) { - oprot.writeFieldBegin(CATEGORY_FIELD_DESC); - oprot.writeString(struct.category); - oprot.writeFieldEnd(); - } - if (struct.option != null) { - oprot.writeFieldBegin(OPTION_FIELD_DESC); - oprot.writeString(struct.option); - oprot.writeFieldEnd(); - } - if (struct.value != null) { - oprot.writeFieldBegin(VALUE_FIELD_DESC); - oprot.writeString(struct.value); - oprot.writeFieldEnd(); - } - if (struct.section != null) { - oprot.writeFieldBegin(SECTION_FIELD_DESC); - oprot.writeString(struct.section); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - private static class setConfigValue_argsTupleSchemeFactory implements SchemeFactory { - public setConfigValue_argsTupleScheme getScheme() { - return new setConfigValue_argsTupleScheme(); - } - } + /** 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(); + } - private static class setConfigValue_argsTupleScheme extends TupleScheme<setConfigValue_args> { + switch (field) { + } + throw new IllegalStateException(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setConfigValue_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetCategory()) { - optionals.set(0); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getQueueData_args) + return this.equals((getQueueData_args) that); + return false; } - if (struct.isSetOption()) { - optionals.set(1); + + public boolean equals(getQueueData_args that) { + if (that == null) + return false; + + return true; } - if (struct.isSetValue()) { - optionals.set(2); + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + return list.hashCode(); } - if (struct.isSetSection()) { - optionals.set(3); + + @Override + public int compareTo(getQueueData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + return 0; } - oprot.writeBitSet(optionals, 4); - if (struct.isSetCategory()) { - oprot.writeString(struct.category); + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - if (struct.isSetOption()) { - oprot.writeString(struct.option); + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - if (struct.isSetValue()) { - oprot.writeString(struct.value); + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - if (struct.isSetSection()) { - oprot.writeString(struct.section); + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getQueueData_args("); + boolean first = true; + + sb.append(")"); + return sb.toString(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setConfigValue_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.category = iprot.readString(); - struct.setCategoryIsSet(true); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - if (incoming.get(1)) { - struct.option = iprot.readString(); - struct.setOptionIsSet(true); + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - if (incoming.get(2)) { - struct.value = iprot.readString(); - struct.setValueIsSet(true); + + 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); + } } - if (incoming.get(3)) { - struct.section = iprot.readString(); - struct.setSectionIsSet(true); + + private static class getQueueData_argsStandardSchemeFactory implements SchemeFactory { + public getQueueData_argsStandardScheme getScheme() { + return new getQueueData_argsStandardScheme(); + } } - } - } - } + private static class getQueueData_argsStandardScheme extends StandardScheme<getQueueData_args> { - public static class setConfigValue_result implements org.apache.thrift.TBase<setConfigValue_result, setConfigValue_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setConfigValue_result"); + public void read(org.apache.thrift.protocol.TProtocol iprot, getQueueData_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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setConfigValue_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setConfigValue_resultTupleSchemeFactory()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getQueueData_args struct) throws org.apache.thrift.TException { + struct.validate(); + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setConfigValue_result.class, metaDataMap); - } + } - public setConfigValue_result() { - } + private static class getQueueData_argsTupleSchemeFactory implements SchemeFactory { + public getQueueData_argsTupleScheme getScheme() { + return new getQueueData_argsTupleScheme(); + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setConfigValue_result(setConfigValue_result other) { - } + private static class getQueueData_argsTupleScheme extends TupleScheme<getQueueData_args> { - public setConfigValue_result deepCopy() { - return new setConfigValue_result(this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getQueueData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - @Override - public void clear() { - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getQueueData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public static class getQueueData_result implements org.apache.thrift.TBase<getQueueData_result, getQueueData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getQueueData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueueData_result"); - /** 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(); - } + 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); - switch (field) { - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setConfigValue_result) - return this.equals((setConfigValue_result)that); - return false; - } + static { + schemes.put(StandardScheme.class, new getQueueData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getQueueData_resultTupleSchemeFactory()); + } - public boolean equals(setConfigValue_result that) { - if (that == null) - return false; + public List<PackageData> success; // required - return true; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(setConfigValue_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public getQueueData_result(android.os.Parcel in) { + this.success = new ArrayList<PackageData>(); + in.readTypedList(this.success, PackageData.CREATOR); + } - int lastComparison = 0; - setConfigValue_result typedOther = (setConfigValue_result)other; + public static final android.os.Parcelable.Creator<getQueueData_result> CREATOR = new android.os.Parcelable.Creator<getQueueData_result>() { + @Override + public getQueueData_result[] newArray(int size) { + return new getQueueData_result[size]; + } - return 0; - } + @Override + public getQueueData_result createFromParcel(android.os.Parcel in) { + return new getQueueData_result(in); + } + }; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** 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"); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setConfigValue_result("); - boolean first = true; + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - sb.append(")"); - return sb.toString(); - } + /** + * 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; + } - public void validate() throws org.apache.thrift.TException { - // check for required 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 void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private final short _thriftId; + private final String _fieldName; - 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.getMessage()); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class setConfigValue_resultStandardSchemeFactory implements SchemeFactory { - public setConfigValue_resultStandardScheme getScheme() { - return new setConfigValue_resultStandardScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } - private static class setConfigValue_resultStandardScheme extends StandardScheme<setConfigValue_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setConfigValue_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) { - 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, setConfigValue_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueueData_result.class, metaDataMap); + } - private static class setConfigValue_resultTupleSchemeFactory implements SchemeFactory { - public setConfigValue_resultTupleScheme getScheme() { - return new setConfigValue_resultTupleScheme(); - } - } + public getQueueData_result() { + } - private static class setConfigValue_resultTupleScheme extends TupleScheme<setConfigValue_result> { + public getQueueData_result( + List<PackageData> success) { + this(); + this.success = success; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setConfigValue_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getQueueData_result(getQueueData_result other) { + if (other.isSetSuccess()) { + List<PackageData> __this__success = new ArrayList<PackageData>(other.success.size()); + for (PackageData other_element : other.success) { + __this__success.add(new PackageData(other_element)); + } + this.success = __this__success; + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setConfigValue_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public getQueueData_result deepCopy() { + return new getQueueData_result(this); + } - } + @Override + public void clear() { + this.success = null; + } - public static class getConfig_args implements org.apache.thrift.TBase<getConfig_args, getConfig_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfig_args"); + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } + public java.util.Iterator<PackageData> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getConfig_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getConfig_argsTupleSchemeFactory()); - } + public void addToSuccess(PackageData elem) { + if (this.success == null) { + this.success = new ArrayList<PackageData>(); + } + this.success.add(elem); + } + public List<PackageData> getSuccess() { + return this.success; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfig_args.class, metaDataMap); - } + public getQueueData_result setSuccess(List<PackageData> success) { + this.success = success; + return this; + } - public getConfig_args() { - } + public void unsetSuccess() { + this.success = null; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getConfig_args(getConfig_args other) { - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public getConfig_args deepCopy() { - return new getConfig_args(this); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<PackageData>) value); + } + break; + + } + } - @Override - public void clear() { - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + } + throw new IllegalStateException(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getQueueData_result) + return this.equals((getQueueData_result) that); + return false; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getConfig_args) - return this.equals((getConfig_args)that); - return false; - } + public boolean equals(getQueueData_result that) { + if (that == null) + return false; - public boolean equals(getConfig_args that) { - if (that == null) - return false; + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } - return true; - } + return true; + } - @Override - public int hashCode() { - return 0; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public int compareTo(getConfig_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - int lastComparison = 0; - getConfig_args typedOther = (getConfig_args)other; + return list.hashCode(); + } - return 0; - } + @Override + public int compareTo(getQueueData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + int lastComparison = 0; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getConfig_args("); - boolean first = true; + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - sb.append(")"); - return sb.toString(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getQueueData_result("); + boolean first = true; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - 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.getMessage()); - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static class getConfig_argsStandardSchemeFactory implements SchemeFactory { - public getConfig_argsStandardScheme getScheme() { - return new getConfig_argsStandardScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class getConfig_argsStandardScheme extends StandardScheme<getConfig_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getConfig_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, getConfig_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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 getQueueData_resultStandardSchemeFactory implements SchemeFactory { + public getQueueData_resultStandardScheme getScheme() { + return new getQueueData_resultStandardScheme(); + } + } - private static class getConfig_argsTupleSchemeFactory implements SchemeFactory { - public getConfig_argsTupleScheme getScheme() { - return new getConfig_argsTupleScheme(); - } - } + private static class getQueueData_resultStandardScheme extends StandardScheme<getQueueData_result> { - private static class getConfig_argsTupleScheme extends TupleScheme<getConfig_args> { + public void read(org.apache.thrift.protocol.TProtocol iprot, getQueueData_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 _list222 = iprot.readListBegin(); + struct.success = new ArrayList<PackageData>(_list222.size); + PackageData _elem223; + for (int _i224 = 0; _i224 < _list222.size; ++_i224) { + _elem223 = new PackageData(); + _elem223.read(iprot); + struct.success.add(_elem223); + } + iprot.readListEnd(); + } + 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(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getConfig_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getConfig_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getQueueData_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 (PackageData _iter225 : struct.success) { + _iter225.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public static class getConfig_result implements org.apache.thrift.TBase<getConfig_result, getConfig_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getConfig_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 class getQueueData_resultTupleSchemeFactory implements SchemeFactory { + public getQueueData_resultTupleScheme getScheme() { + return new getQueueData_resultTupleScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getConfig_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getConfig_resultTupleSchemeFactory()); - } + private static class getQueueData_resultTupleScheme extends TupleScheme<getQueueData_result> { - public Map<String,ConfigSection> 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 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 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 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; - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getQueueData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (PackageData _iter226 : struct.success) { + _iter226.write(oprot); + } + } + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ConfigSection.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getConfig_result.class, metaDataMap); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getQueueData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list227 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<PackageData>(_list227.size); + PackageData _elem228; + for (int _i229 = 0; _i229 < _list227.size; ++_i229) { + _elem228 = new PackageData(); + _elem228.read(iprot); + struct.success.add(_elem228); + } + } + struct.setSuccessIsSet(true); + } + } + } - public getConfig_result() { } - public getConfig_result( - Map<String,ConfigSection> success) - { - this(); - this.success = success; - } + public static class getCollectorData_args implements org.apache.thrift.TBase<getCollectorData_args, getCollectorData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCollectorData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollectorData_args"); - /** - * Performs a deep copy on <i>other</i>. - */ - public getConfig_result(getConfig_result other) { - if (other.isSetSuccess()) { - Map<String,ConfigSection> __this__success = new HashMap<String,ConfigSection>(); - for (Map.Entry<String, ConfigSection> other_element : other.success.entrySet()) { - String other_element_key = other_element.getKey(); - ConfigSection other_element_value = other_element.getValue(); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - String __this__success_copy_key = other_element_key; + static { + schemes.put(StandardScheme.class, new getCollectorData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCollectorData_argsTupleSchemeFactory()); + } - ConfigSection __this__success_copy_value = new ConfigSection(other_element_value); - __this__success.put(__this__success_copy_key, __this__success_copy_value); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - this.success = __this__success; - } - } - - public getConfig_result deepCopy() { - return new getConfig_result(this); - } - @Override - public void clear() { - this.success = null; - } + @Override + public int describeContents() { + return 0; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public getCollectorData_args(android.os.Parcel in) { + } - public void putToSuccess(String key, ConfigSection val) { - if (this.success == null) { - this.success = new HashMap<String,ConfigSection>(); - } - this.success.put(key, val); - } + public static final android.os.Parcelable.Creator<getCollectorData_args> CREATOR = new android.os.Parcelable.Creator<getCollectorData_args>() { + @Override + public getCollectorData_args[] newArray(int size) { + return new getCollectorData_args[size]; + } - public Map<String,ConfigSection> getSuccess() { - return this.success; - } + @Override + public getCollectorData_args createFromParcel(android.os.Parcel in) { + return new getCollectorData_args(in); + } + }; - public getConfig_result setSuccess(Map<String,ConfigSection> success) { - this.success = success; - return this; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void unsetSuccess() { - this.success = null; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,ConfigSection>)value); - } - break; + /** + * 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); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + private final short _thriftId; + private final String _fieldName; - } - throw new IllegalStateException(); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getConfig_result) - return this.equals((getConfig_result)that); - return false; - } + public String getFieldName() { + return _fieldName; + } + } - public boolean equals(getConfig_result that) { - if (that == null) - return false; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - 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; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollectorData_args.class, metaDataMap); + } - return true; - } + public getCollectorData_args() { + } - @Override - public int hashCode() { - return 0; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getCollectorData_args(getCollectorData_args other) { + } - public int compareTo(getConfig_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getConfig_result typedOther = (getConfig_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public getCollectorData_args deepCopy() { + return new getCollectorData_args(this); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void clear() { + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - 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("getConfig_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 Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** 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(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + switch (field) { + } + throw new IllegalStateException(); + } - 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.getMessage()); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCollectorData_args) + return this.equals((getCollectorData_args) that); + return false; + } - private static class getConfig_resultStandardSchemeFactory implements SchemeFactory { - public getConfig_resultStandardScheme getScheme() { - return new getConfig_resultStandardScheme(); - } - } + public boolean equals(getCollectorData_args that) { + if (that == null) + return false; - private static class getConfig_resultStandardScheme extends StandardScheme<getConfig_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getConfig_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 _map60 = iprot.readMapBegin(); - struct.success = new HashMap<String,ConfigSection>(2*_map60.size); - for (int _i61 = 0; _i61 < _map60.size; ++_i61) - { - String _key62; // required - ConfigSection _val63; // required - _key62 = iprot.readString(); - _val63 = new ConfigSection(); - _val63.read(iprot); - struct.success.put(_key62, _val63); - } - iprot.readMapEnd(); - } - 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, getConfig_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 (Map.Entry<String, ConfigSection> _iter64 : struct.success.entrySet()) - { - oprot.writeString(_iter64.getKey()); - _iter64.getValue().write(oprot); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return true; + } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class getConfig_resultTupleSchemeFactory implements SchemeFactory { - public getConfig_resultTupleScheme getScheme() { - return new getConfig_resultTupleScheme(); - } - } + return list.hashCode(); + } - private static class getConfig_resultTupleScheme extends TupleScheme<getConfig_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getConfig_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, ConfigSection> _iter65 : struct.success.entrySet()) - { - oprot.writeString(_iter65.getKey()); - _iter65.getValue().write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getConfig_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map66 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap<String,ConfigSection>(2*_map66.size); - for (int _i67 = 0; _i67 < _map66.size; ++_i67) - { - String _key68; // required - ConfigSection _val69; // required - _key68 = iprot.readString(); - _val69 = new ConfigSection(); - _val69.read(iprot); - struct.success.put(_key68, _val69); - } - } - struct.setSuccessIsSet(true); - } - } - } + @Override + public int compareTo(getCollectorData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - } + int lastComparison = 0; - public static class getPluginConfig_args implements org.apache.thrift.TBase<getPluginConfig_args, getPluginConfig_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPluginConfig_args"); + return 0; + } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPluginConfig_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPluginConfig_argsTupleSchemeFactory()); - } + 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); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPluginConfig_args.class, metaDataMap); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCollectorData_args("); + boolean first = true; - public getPluginConfig_args() { - } + sb.append(")"); + return sb.toString(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getPluginConfig_args(getPluginConfig_args other) { - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public getPluginConfig_args deepCopy() { - return new getPluginConfig_args(this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public void clear() { - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class getCollectorData_argsStandardSchemeFactory implements SchemeFactory { + public getCollectorData_argsStandardScheme getScheme() { + return new getCollectorData_argsStandardScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static class getCollectorData_argsStandardScheme extends StandardScheme<getCollectorData_args> { - /** 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(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCollectorData_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(); - switch (field) { - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPluginConfig_args) - return this.equals((getPluginConfig_args)that); - return false; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCollectorData_args struct) throws org.apache.thrift.TException { + struct.validate(); - public boolean equals(getPluginConfig_args that) { - if (that == null) - return false; + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - return true; - } + } - @Override - public int hashCode() { - return 0; - } + private static class getCollectorData_argsTupleSchemeFactory implements SchemeFactory { + public getCollectorData_argsTupleScheme getScheme() { + return new getCollectorData_argsTupleScheme(); + } + } - public int compareTo(getPluginConfig_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + private static class getCollectorData_argsTupleScheme extends TupleScheme<getCollectorData_args> { - int lastComparison = 0; - getPluginConfig_args typedOther = (getPluginConfig_args)other; + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCollectorData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCollectorData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - 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 static class getCollectorData_result implements org.apache.thrift.TBase<getCollectorData_result, getCollectorData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCollectorData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollectorData_result"); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getPluginConfig_args("); - boolean first = true; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - sb.append(")"); - return sb.toString(); - } + static { + schemes.put(StandardScheme.class, new getCollectorData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCollectorData_resultTupleSchemeFactory()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public List<PackageData> success; // required - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } - 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.getMessage()); - } - } + @Override + public int describeContents() { + return 0; + } - private static class getPluginConfig_argsStandardSchemeFactory implements SchemeFactory { - public getPluginConfig_argsStandardScheme getScheme() { - return new getPluginConfig_argsStandardScheme(); - } - } + public getCollectorData_result(android.os.Parcel in) { + this.success = new ArrayList<PackageData>(); + in.readTypedList(this.success, PackageData.CREATOR); + } - private static class getPluginConfig_argsStandardScheme extends StandardScheme<getPluginConfig_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPluginConfig_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, getPluginConfig_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public static final android.os.Parcelable.Creator<getCollectorData_result> CREATOR = new android.os.Parcelable.Creator<getCollectorData_result>() { + @Override + public getCollectorData_result[] newArray(int size) { + return new getCollectorData_result[size]; + } - } + @Override + public getCollectorData_result createFromParcel(android.os.Parcel in) { + return new getCollectorData_result(in); + } + }; - private static class getPluginConfig_argsTupleSchemeFactory implements SchemeFactory { - public getPluginConfig_argsTupleScheme getScheme() { - return new getPluginConfig_argsTupleScheme(); - } - } + /** 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 class getPluginConfig_argsTupleScheme extends TupleScheme<getPluginConfig_args> { + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + 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; + } - public static class getPluginConfig_result implements org.apache.thrift.TBase<getPluginConfig_result, getPluginConfig_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPluginConfig_result"); + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - 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 final short _thriftId; + private final String _fieldName; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPluginConfig_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPluginConfig_resultTupleSchemeFactory()); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public Map<String,ConfigSection> 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 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 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 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; - } - } + public short getThriftFieldId() { + return _thriftId; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ConfigSection.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPluginConfig_result.class, metaDataMap); - } + public String getFieldName() { + return _fieldName; + } + } - public getPluginConfig_result() { - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public getPluginConfig_result( - Map<String,ConfigSection> success) - { - this(); - this.success = success; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollectorData_result.class, metaDataMap); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getPluginConfig_result(getPluginConfig_result other) { - if (other.isSetSuccess()) { - Map<String,ConfigSection> __this__success = new HashMap<String,ConfigSection>(); - for (Map.Entry<String, ConfigSection> other_element : other.success.entrySet()) { + public getCollectorData_result() { + } - String other_element_key = other_element.getKey(); - ConfigSection other_element_value = other_element.getValue(); + public getCollectorData_result( + List<PackageData> success) { + this(); + this.success = success; + } - String __this__success_copy_key = other_element_key; + /** + * Performs a deep copy on <i>other</i>. + */ + public getCollectorData_result(getCollectorData_result other) { + if (other.isSetSuccess()) { + List<PackageData> __this__success = new ArrayList<PackageData>(other.success.size()); + for (PackageData other_element : other.success) { + __this__success.add(new PackageData(other_element)); + } + this.success = __this__success; + } + } - ConfigSection __this__success_copy_value = new ConfigSection(other_element_value); + public getCollectorData_result deepCopy() { + return new getCollectorData_result(this); + } - __this__success.put(__this__success_copy_key, __this__success_copy_value); + @Override + public void clear() { + this.success = null; } - this.success = __this__success; - } - } - public getPluginConfig_result deepCopy() { - return new getPluginConfig_result(this); - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - @Override - public void clear() { - this.success = null; - } + public java.util.Iterator<PackageData> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public void addToSuccess(PackageData elem) { + if (this.success == null) { + this.success = new ArrayList<PackageData>(); + } + this.success.add(elem); + } - public void putToSuccess(String key, ConfigSection val) { - if (this.success == null) { - this.success = new HashMap<String,ConfigSection>(); - } - this.success.put(key, val); - } + public List<PackageData> getSuccess() { + return this.success; + } - public Map<String,ConfigSection> getSuccess() { - return this.success; - } + public getCollectorData_result setSuccess(List<PackageData> success) { + this.success = success; + return this; + } - public getPluginConfig_result setSuccess(Map<String,ConfigSection> success) { - this.success = success; - return this; - } + public void unsetSuccess() { + this.success = null; + } - 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; + } - /** 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 setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<PackageData>) value); + } + break; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,ConfigSection>)value); + } } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - } - throw new IllegalStateException(); - } + } + throw new IllegalStateException(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - 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(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPluginConfig_result) - return this.equals((getPluginConfig_result)that); - return false; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public boolean equals(getPluginConfig_result that) { - if (that == null) - return false; + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCollectorData_result) + return this.equals((getCollectorData_result) that); + return false; + } - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } + public boolean equals(getCollectorData_result that) { + if (that == null) + return false; - 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; + } - @Override - public int hashCode() { - return 0; - } + return true; + } - public int compareTo(getPluginConfig_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPluginConfig_result typedOther = (getPluginConfig_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return list.hashCode(); + } - 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("getPluginConfig_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(); - } + @Override + public int compareTo(getCollectorData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + int lastComparison = 0; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - 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.getMessage()); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class getPluginConfig_resultStandardSchemeFactory implements SchemeFactory { - public getPluginConfig_resultStandardScheme getScheme() { - return new getPluginConfig_resultStandardScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class getPluginConfig_resultStandardScheme extends StandardScheme<getPluginConfig_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPluginConfig_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 _map70 = iprot.readMapBegin(); - struct.success = new HashMap<String,ConfigSection>(2*_map70.size); - for (int _i71 = 0; _i71 < _map70.size; ++_i71) - { - String _key72; // required - ConfigSection _val73; // required - _key72 = iprot.readString(); - _val73 = new ConfigSection(); - _val73.read(iprot); - struct.success.put(_key72, _val73); - } - iprot.readMapEnd(); - } - 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, getPluginConfig_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 (Map.Entry<String, ConfigSection> _iter74 : struct.success.entrySet()) - { - oprot.writeString(_iter74.getKey()); - _iter74.getValue().write(oprot); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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("getCollectorData_result("); + boolean first = true; - private static class getPluginConfig_resultTupleSchemeFactory implements SchemeFactory { - public getPluginConfig_resultTupleScheme getScheme() { - return new getPluginConfig_resultTupleScheme(); - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class getPluginConfig_resultTupleScheme extends TupleScheme<getPluginConfig_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, ConfigSection> _iter75 : struct.success.entrySet()) - { - oprot.writeString(_iter75.getKey()); - _iter75.getValue().write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPluginConfig_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map76 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap<String,ConfigSection>(2*_map76.size); - for (int _i77 = 0; _i77 < _map76.size; ++_i77) - { - String _key78; // required - ConfigSection _val79; // required - _key78 = iprot.readString(); - _val79 = new ConfigSection(); - _val79.read(iprot); - struct.success.put(_key78, _val79); - } - } - struct.setSuccessIsSet(true); - } - } - } + 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); + } + } - public static class pauseServer_args implements org.apache.thrift.TBase<pauseServer_args, pauseServer_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pauseServer_args"); + 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 getCollectorData_resultStandardSchemeFactory implements SchemeFactory { + public getCollectorData_resultStandardScheme getScheme() { + return new getCollectorData_resultStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pauseServer_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pauseServer_argsTupleSchemeFactory()); - } + private static class getCollectorData_resultStandardScheme extends StandardScheme<getCollectorData_result> { + public void read(org.apache.thrift.protocol.TProtocol iprot, getCollectorData_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 _list230 = iprot.readListBegin(); + struct.success = new ArrayList<PackageData>(_list230.size); + PackageData _elem231; + for (int _i232 = 0; _i232 < _list230.size; ++_i232) { + _elem231 = new PackageData(); + _elem231.read(iprot); + struct.success.add(_elem231); + } + iprot.readListEnd(); + } + 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(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pauseServer_args.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public pauseServer_args() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCollectorData_result struct) throws org.apache.thrift.TException { + struct.validate(); - /** - * Performs a deep copy on <i>other</i>. - */ - public pauseServer_args(pauseServer_args other) { - } + 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 (PackageData _iter233 : struct.success) { + _iter233.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public pauseServer_args deepCopy() { - return new pauseServer_args(this); - } + } - @Override - public void clear() { - } + private static class getCollectorData_resultTupleSchemeFactory implements SchemeFactory { + public getCollectorData_resultTupleScheme getScheme() { + return new getCollectorData_resultTupleScheme(); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class getCollectorData_resultTupleScheme extends TupleScheme<getCollectorData_result> { - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCollectorData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (PackageData _iter234 : struct.success) { + _iter234.write(oprot); + } + } + } + } - /** 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(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCollectorData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list235 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<PackageData>(_list235.size); + PackageData _elem236; + for (int _i237 = 0; _i237 < _list235.size; ++_i237) { + _elem236 = new PackageData(); + _elem236.read(iprot); + struct.success.add(_elem236); + } + } + struct.setSuccessIsSet(true); + } + } + } - switch (field) { - } - throw new IllegalStateException(); } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pauseServer_args) - return this.equals((pauseServer_args)that); - return false; - } + public static class getPackageOrder_args implements org.apache.thrift.TBase<getPackageOrder_args, getPackageOrder_args._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageOrder_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageOrder_args"); - public boolean equals(pauseServer_args that) { - if (that == null) - return false; + private static final org.apache.thrift.protocol.TField DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short) 1); - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new getPackageOrder_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageOrder_argsTupleSchemeFactory()); + } - public int compareTo(pauseServer_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + /** + * + * @see Destination + */ + public Destination destination; // required - int lastComparison = 0; - pauseServer_args typedOther = (pauseServer_args)other; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeInt(destination.getValue()); + } - return 0; - } + @Override + public int describeContents() { + return 0; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public getPackageOrder_args(android.os.Parcel in) { + this.destination = Destination.findByValue(in.readInt()); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public static final android.os.Parcelable.Creator<getPackageOrder_args> CREATOR = new android.os.Parcelable.Creator<getPackageOrder_args>() { + @Override + public getPackageOrder_args[] newArray(int size) { + return new getPackageOrder_args[size]; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public getPackageOrder_args createFromParcel(android.os.Parcel in) { + return new getPackageOrder_args(in); + } + }; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pauseServer_args("); - boolean first = true; + /** 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 Destination + */ + DESTINATION((short) 1, "destination"); - sb.append(")"); - return sb.toString(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // DESTINATION + return DESTINATION; + default: + return null; + } + } - 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.getMessage()); - } - } + /** + * 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; + } - private static class pauseServer_argsStandardSchemeFactory implements SchemeFactory { - public pauseServer_argsStandardScheme getScheme() { - return new pauseServer_argsStandardScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class pauseServer_argsStandardScheme extends StandardScheme<pauseServer_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pauseServer_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, pauseServer_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class pauseServer_argsTupleSchemeFactory implements SchemeFactory { - public pauseServer_argsTupleScheme getScheme() { - return new pauseServer_argsTupleScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class pauseServer_argsTupleScheme extends TupleScheme<pauseServer_args> { + public String getFieldName() { + return _fieldName; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pauseServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pauseServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageOrder_args.class, metaDataMap); + } - } + public getPackageOrder_args() { + } - public static class pauseServer_result implements org.apache.thrift.TBase<pauseServer_result, pauseServer_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pauseServer_result"); + public getPackageOrder_args( + Destination destination) { + this(); + this.destination = destination; + } + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageOrder_args(getPackageOrder_args other) { + if (other.isSetDestination()) { + this.destination = other.destination; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pauseServer_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pauseServer_resultTupleSchemeFactory()); - } + public getPackageOrder_args deepCopy() { + return new getPackageOrder_args(this); + } + @Override + public void clear() { + this.destination = null; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pauseServer_result.class, metaDataMap); - } + /** + * + * @see Destination + */ + public Destination getDestination() { + return this.destination; + } - public pauseServer_result() { - } + /** + * + * @see Destination + */ + public getPackageOrder_args setDestination(Destination destination) { + this.destination = destination; + return this; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pauseServer_result(pauseServer_result other) { - } + public void unsetDestination() { + this.destination = null; + } - public pauseServer_result deepCopy() { - return new pauseServer_result(this); - } + /** Returns true if field destination is set (has been assigned a value) and false otherwise */ + public boolean isSetDestination() { + return this.destination != null; + } - @Override - public void clear() { - } + public void setDestinationIsSet(boolean value) { + if (!value) { + this.destination = null; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DESTINATION: + if (value == null) { + unsetDestination(); + } else { + setDestination((Destination) value); + } + break; - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case DESTINATION: + return getDestination(); - switch (field) { - } - throw new IllegalStateException(); - } + } + throw new IllegalStateException(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pauseServer_result) - return this.equals((pauseServer_result)that); - return false; - } + /** 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(); + } - public boolean equals(pauseServer_result that) { - if (that == null) - return false; + switch (field) { + case DESTINATION: + return isSetDestination(); + } + throw new IllegalStateException(); + } - return true; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageOrder_args) + return this.equals((getPackageOrder_args) that); + return false; + } - @Override - public int hashCode() { - return 0; - } + public boolean equals(getPackageOrder_args that) { + if (that == null) + return false; - public int compareTo(pauseServer_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + boolean this_present_destination = true && this.isSetDestination(); + boolean that_present_destination = true && that.isSetDestination(); + if (this_present_destination || that_present_destination) { + if (!(this_present_destination && that_present_destination)) + return false; + if (!this.destination.equals(that.destination)) + return false; + } - int lastComparison = 0; - pauseServer_result typedOther = (pauseServer_result)other; + return true; + } - return 0; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + boolean present_destination = true && (isSetDestination()); + list.add(present_destination); + if (present_destination) + list.add(destination.getValue()); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return list.hashCode(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public int compareTo(getPackageOrder_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pauseServer_result("); - boolean first = true; + int lastComparison = 0; - sb.append(")"); - return sb.toString(); - } + lastComparison = Boolean.valueOf(isSetDestination()).compareTo(other.isSetDestination()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDestination()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, other.destination); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class pauseServer_resultStandardSchemeFactory implements SchemeFactory { - public pauseServer_resultStandardScheme getScheme() { - return new pauseServer_resultStandardScheme(); - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getPackageOrder_args("); + boolean first = true; - private static class pauseServer_resultStandardScheme extends StandardScheme<pauseServer_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pauseServer_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) { - 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, pauseServer_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + sb.append("destination:"); + if (this.destination == null) { + sb.append("null"); + } else { + sb.append(this.destination); + } + 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 static class pauseServer_resultTupleSchemeFactory implements SchemeFactory { - public pauseServer_resultTupleScheme getScheme() { - return new pauseServer_resultTupleScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class pauseServer_resultTupleScheme extends TupleScheme<pauseServer_result> { + 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); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pauseServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + private static class getPackageOrder_argsStandardSchemeFactory implements SchemeFactory { + public getPackageOrder_argsStandardScheme getScheme() { + return new getPackageOrder_argsStandardScheme(); + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pauseServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + private static class getPackageOrder_argsStandardScheme extends StandardScheme<getPackageOrder_args> { - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageOrder_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: // DESTINATION + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(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(); - public static class unpauseServer_args implements org.apache.thrift.TBase<unpauseServer_args, unpauseServer_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("unpauseServer_args"); + // 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, getPackageOrder_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new unpauseServer_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new unpauseServer_argsTupleSchemeFactory()); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.destination != null) { + oprot.writeFieldBegin(DESTINATION_FIELD_DESC); + oprot.writeI32(struct.destination.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(unpauseServer_args.class, metaDataMap); - } + private static class getPackageOrder_argsTupleSchemeFactory implements SchemeFactory { + public getPackageOrder_argsTupleScheme getScheme() { + return new getPackageOrder_argsTupleScheme(); + } + } - public unpauseServer_args() { - } + private static class getPackageOrder_argsTupleScheme extends TupleScheme<getPackageOrder_args> { - /** - * Performs a deep copy on <i>other</i>. - */ - public unpauseServer_args(unpauseServer_args other) { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDestination()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetDestination()) { + oprot.writeI32(struct.destination.getValue()); + } + } - public unpauseServer_args deepCopy() { - return new unpauseServer_args(this); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(true); + } + } + } - @Override - public void clear() { } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public static class getPackageOrder_result implements org.apache.thrift.TBase<getPackageOrder_result, getPackageOrder_result._Fields>, java.io.Serializable, Cloneable, Comparable<getPackageOrder_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageOrder_result"); - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + 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); - /** 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(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - switch (field) { - } - throw new IllegalStateException(); - } + static { + schemes.put(StandardScheme.class, new getPackageOrder_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getPackageOrder_resultTupleSchemeFactory()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof unpauseServer_args) - return this.equals((unpauseServer_args)that); - return false; - } + public Map<Short, Integer> success; // required - public boolean equals(unpauseServer_args that) { - if (that == null) - return false; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } - return true; - } + @Override + public int describeContents() { + return 0; + } - @Override - public int hashCode() { - return 0; - } + public getPackageOrder_result(android.os.Parcel in) { + this.success = new HashMap<Short, Integer>(); + in.readMap(this.success, getPackageOrder_result.class.getClassLoader()); + } - public int compareTo(unpauseServer_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public static final android.os.Parcelable.Creator<getPackageOrder_result> CREATOR = new android.os.Parcelable.Creator<getPackageOrder_result>() { + @Override + public getPackageOrder_result[] newArray(int size) { + return new getPackageOrder_result[size]; + } - int lastComparison = 0; - unpauseServer_args typedOther = (unpauseServer_args)other; + @Override + public getPackageOrder_result createFromParcel(android.os.Parcel in) { + return new getPackageOrder_result(in); + } + }; - return 0; - } + /** 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"); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("unpauseServer_args("); - boolean first = true; + /** + * 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; + } - sb.append(")"); - return sb.toString(); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private final short _thriftId; + private final String _fieldName; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - 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.getMessage()); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class unpauseServer_argsStandardSchemeFactory implements SchemeFactory { - public unpauseServer_argsStandardScheme getScheme() { - return new unpauseServer_argsStandardScheme(); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class unpauseServer_argsStandardScheme extends StandardScheme<unpauseServer_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, unpauseServer_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, unpauseServer_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageOrder_result.class, metaDataMap); + } - private static class unpauseServer_argsTupleSchemeFactory implements SchemeFactory { - public unpauseServer_argsTupleScheme getScheme() { - return new unpauseServer_argsTupleScheme(); - } - } + public getPackageOrder_result() { + } - private static class unpauseServer_argsTupleScheme extends TupleScheme<unpauseServer_args> { + public getPackageOrder_result( + Map<Short, Integer> success) { + this(); + this.success = success; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, unpauseServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getPackageOrder_result(getPackageOrder_result other) { + if (other.isSetSuccess()) { + Map<Short, Integer> __this__success = new HashMap<Short, Integer>(other.success.size()); + for (Map.Entry<Short, Integer> other_element : other.success.entrySet()) { - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, unpauseServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + Short other_element_key = other_element.getKey(); + Integer other_element_value = other_element.getValue(); - } + Short __this__success_copy_key = other_element_key; - public static class unpauseServer_result implements org.apache.thrift.TBase<unpauseServer_result, unpauseServer_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("unpauseServer_result"); + Integer __this__success_copy_value = other_element_value; + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new unpauseServer_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new unpauseServer_resultTupleSchemeFactory()); - } + public getPackageOrder_result deepCopy() { + return new getPackageOrder_result(this); + } + @Override + public void clear() { + this.success = null; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(unpauseServer_result.class, metaDataMap); - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - public unpauseServer_result() { - } + public void putToSuccess(short key, int val) { + if (this.success == null) { + this.success = new HashMap<Short, Integer>(); + } + this.success.put(key, val); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public unpauseServer_result(unpauseServer_result other) { - } + public Map<Short, Integer> getSuccess() { + return this.success; + } - public unpauseServer_result deepCopy() { - return new unpauseServer_result(this); - } + public getPackageOrder_result setSuccess(Map<Short, Integer> success) { + this.success = success; + return this; + } - @Override - public void clear() { - } + public void unsetSuccess() { + this.success = null; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - /** 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(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<Short, Integer>) value); + } + break; - switch (field) { - } - throw new IllegalStateException(); - } + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof unpauseServer_result) - return this.equals((unpauseServer_result)that); - return false; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public boolean equals(unpauseServer_result that) { - if (that == null) - return false; + } + throw new IllegalStateException(); + } - return true; - } + /** 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(); + } - @Override - public int hashCode() { - return 0; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public int compareTo(unpauseServer_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getPackageOrder_result) + return this.equals((getPackageOrder_result) that); + return false; + } - int lastComparison = 0; - unpauseServer_result typedOther = (unpauseServer_result)other; + public boolean equals(getPackageOrder_result that) { + if (that == null) + return false; - return 0; - } + 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; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + return true; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("unpauseServer_result("); - boolean first = true; + return list.hashCode(); + } - sb.append(")"); - return sb.toString(); - } + @Override + public int compareTo(getPackageOrder_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + int lastComparison = 0; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - 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.getMessage()); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class unpauseServer_resultStandardSchemeFactory implements SchemeFactory { - public unpauseServer_resultStandardScheme getScheme() { - return new unpauseServer_resultStandardScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class unpauseServer_resultStandardScheme extends StandardScheme<unpauseServer_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, unpauseServer_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) { - 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, unpauseServer_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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("getPackageOrder_result("); + boolean first = true; - private static class unpauseServer_resultTupleSchemeFactory implements SchemeFactory { - public unpauseServer_resultTupleScheme getScheme() { - return new unpauseServer_resultTupleScheme(); - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class unpauseServer_resultTupleScheme extends TupleScheme<unpauseServer_result> { + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, unpauseServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, unpauseServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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 getPackageOrder_resultStandardSchemeFactory implements SchemeFactory { + public getPackageOrder_resultStandardScheme getScheme() { + return new getPackageOrder_resultStandardScheme(); + } + } - public static class togglePause_args implements org.apache.thrift.TBase<togglePause_args, togglePause_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("togglePause_args"); + private static class getPackageOrder_resultStandardScheme extends StandardScheme<getPackageOrder_result> { + public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageOrder_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 _map238 = iprot.readMapBegin(); + struct.success = new HashMap<Short, Integer>(2 * _map238.size); + short _key239; + int _val240; + for (int _i241 = 0; _i241 < _map238.size; ++_i241) { + _key239 = iprot.readI16(); + _val240 = iprot.readI32(); + struct.success.put(_key239, _val240); + } + iprot.readMapEnd(); + } + 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(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new togglePause_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new togglePause_argsTupleSchemeFactory()); - } + // 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, getPackageOrder_result struct) throws org.apache.thrift.TException { + struct.validate(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(togglePause_args.class, metaDataMap); - } + 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.I16, org.apache.thrift.protocol.TType.I32, struct.success.size())); + for (Map.Entry<Short, Integer> _iter242 : struct.success.entrySet()) { + oprot.writeI16(_iter242.getKey()); + oprot.writeI32(_iter242.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public togglePause_args() { - } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public togglePause_args(togglePause_args other) { - } + private static class getPackageOrder_resultTupleSchemeFactory implements SchemeFactory { + public getPackageOrder_resultTupleScheme getScheme() { + return new getPackageOrder_resultTupleScheme(); + } + } - public togglePause_args deepCopy() { - return new togglePause_args(this); - } + private static class getPackageOrder_resultTupleScheme extends TupleScheme<getPackageOrder_result> { - @Override - public void clear() { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<Short, Integer> _iter243 : struct.success.entrySet()) { + oprot.writeI16(_iter243.getKey()); + oprot.writeI32(_iter243.getValue()); + } + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map244 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I16, org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.success = new HashMap<Short, Integer>(2 * _map244.size); + short _key245; + int _val246; + for (int _i247 = 0; _i247 < _map244.size; ++_i247) { + _key245 = iprot.readI16(); + _val246 = iprot.readI32(); + struct.success.put(_key245, _val246); + } + } + struct.setSuccessIsSet(true); + } + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); - } + public static class getFileOrder_args implements org.apache.thrift.TBase<getFileOrder_args, getFileOrder_args._Fields>, java.io.Serializable, Cloneable, Comparable<getFileOrder_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileOrder_args"); - switch (field) { - } - throw new IllegalStateException(); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof togglePause_args) - return this.equals((togglePause_args)that); - return false; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public boolean equals(togglePause_args that) { - if (that == null) - return false; + static { + schemes.put(StandardScheme.class, new getFileOrder_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getFileOrder_argsTupleSchemeFactory()); + } - return true; - } + public int pid; // required - @Override - public int hashCode() { - return 0; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public int compareTo(togglePause_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + out.writeInt(pid); + } - int lastComparison = 0; - togglePause_args typedOther = (togglePause_args)other; + @Override + public int describeContents() { + return 0; + } - return 0; - } + public getFileOrder_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + this.pid = in.readInt(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public static final android.os.Parcelable.Creator<getFileOrder_args> CREATOR = new android.os.Parcelable.Creator<getFileOrder_args>() { + @Override + public getFileOrder_args[] newArray(int size) { + return new getFileOrder_args[size]; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public getFileOrder_args createFromParcel(android.os.Parcel in) { + return new getFileOrder_args(in); + } + }; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("togglePause_args("); - boolean first = true; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - sb.append(")"); - return sb.toString(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - 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.getMessage()); - } - } + /** + * 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; + } - private static class togglePause_argsStandardSchemeFactory implements SchemeFactory { - public togglePause_argsStandardScheme getScheme() { - return new togglePause_argsStandardScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class togglePause_argsStandardScheme extends StandardScheme<togglePause_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, togglePause_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, togglePause_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class togglePause_argsTupleSchemeFactory implements SchemeFactory { - public togglePause_argsTupleScheme getScheme() { - return new togglePause_argsTupleScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class togglePause_argsTupleScheme extends TupleScheme<togglePause_args> { + public String getFieldName() { + return _fieldName; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, togglePause_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, togglePause_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileOrder_args.class, metaDataMap); + } - } + public getFileOrder_args() { + } - public static class togglePause_result implements org.apache.thrift.TBase<togglePause_result, togglePause_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("togglePause_result"); + public getFileOrder_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } - 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); + /** + * Performs a deep copy on <i>other</i>. + */ + public getFileOrder_args(getFileOrder_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new togglePause_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new togglePause_resultTupleSchemeFactory()); - } + public getFileOrder_args deepCopy() { + return new getFileOrder_args(this); + } - public boolean 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 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 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 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; - } - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(togglePause_result.class, metaDataMap); - } + public int getPid() { + return this.pid; + } - public togglePause_result() { - } + public getFileOrder_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public togglePause_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public togglePause_result(togglePause_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - public togglePause_result deepCopy() { - return new togglePause_result(this); - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - public boolean isSuccess() { - return this.success; - } + } + } - public togglePause_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + } + throw new IllegalStateException(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + /** 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(); + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + switch (field) { + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getFileOrder_args) + return this.equals((getFileOrder_args) that); + return false; } - break; - } - } + public boolean equals(getFileOrder_args that) { + if (that == null) + return false; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - } - throw new IllegalStateException(); - } + return true; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof togglePause_result) - return this.equals((togglePause_result)that); - return false; - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public boolean equals(togglePause_result that) { - if (that == null) - return false; + return list.hashCode(); + } - 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; - } + @Override + public int compareTo(getFileOrder_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - return true; - } + int lastComparison = 0; - @Override - public int hashCode() { - return 0; - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public int compareTo(togglePause_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - togglePause_result typedOther = (togglePause_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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 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); + } - 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("getFileOrder_args("); + boolean first = true; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("togglePause_result("); - boolean first = true; + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - sb.append("success:"); - 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 + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 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.getMessage()); - } - } + private static class getFileOrder_argsStandardSchemeFactory implements SchemeFactory { + public getFileOrder_argsStandardScheme getScheme() { + return new getFileOrder_argsStandardScheme(); + } + } - private static class togglePause_resultStandardSchemeFactory implements SchemeFactory { - public togglePause_resultStandardScheme getScheme() { - return new togglePause_resultStandardScheme(); - } - } + private static class getFileOrder_argsStandardScheme extends StandardScheme<getFileOrder_args> { - private static class togglePause_resultStandardScheme extends StandardScheme<togglePause_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, togglePause_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; - 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, togglePause_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getFileOrder_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); + } - private static class togglePause_resultTupleSchemeFactory implements SchemeFactory { - public togglePause_resultTupleScheme getScheme() { - return new togglePause_resultTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getFileOrder_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class togglePause_resultTupleScheme extends TupleScheme<togglePause_result> { + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, togglePause_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, togglePause_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + private static class getFileOrder_argsTupleSchemeFactory implements SchemeFactory { + public getFileOrder_argsTupleScheme getScheme() { + return new getFileOrder_argsTupleScheme(); + } } - } - } - } + private static class getFileOrder_argsTupleScheme extends TupleScheme<getFileOrder_args> { - public static class statusServer_args implements org.apache.thrift.TBase<statusServer_args, statusServer_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusServer_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getFileOrder_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getFileOrder_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new statusServer_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new statusServer_argsTupleSchemeFactory()); } + public static class getFileOrder_result implements org.apache.thrift.TBase<getFileOrder_result, getFileOrder_result._Fields>, java.io.Serializable, Cloneable, Comparable<getFileOrder_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileOrder_result"); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusServer_args.class, metaDataMap); - } - - public statusServer_args() { - } + 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); - /** - * Performs a deep copy on <i>other</i>. - */ - public statusServer_args(statusServer_args other) { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public statusServer_args deepCopy() { - return new statusServer_args(this); - } + static { + schemes.put(StandardScheme.class, new getFileOrder_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getFileOrder_resultTupleSchemeFactory()); + } - @Override - public void clear() { - } + public Map<Short, Integer> success; // required - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int describeContents() { + return 0; + } - /** 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(); - } + public getFileOrder_result(android.os.Parcel in) { + this.success = new HashMap<Short, Integer>(); + in.readMap(this.success, getFileOrder_result.class.getClassLoader()); + } - switch (field) { - } - throw new IllegalStateException(); - } + public static final android.os.Parcelable.Creator<getFileOrder_result> CREATOR = new android.os.Parcelable.Creator<getFileOrder_result>() { + @Override + public getFileOrder_result[] newArray(int size) { + return new getFileOrder_result[size]; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof statusServer_args) - return this.equals((statusServer_args)that); - return false; - } + @Override + public getFileOrder_result createFromParcel(android.os.Parcel in) { + return new getFileOrder_result(in); + } + }; - public boolean equals(statusServer_args that) { - if (that == null) - return false; + /** 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"); - return true; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public int hashCode() { - return 0; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int compareTo(statusServer_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - int lastComparison = 0; - statusServer_args typedOther = (statusServer_args)other; + /** + * 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; + } - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private final short _thriftId; + private final String _fieldName; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("statusServer_args("); - boolean first = true; + public String getFieldName() { + return _fieldName; + } + } - sb.append(")"); - return sb.toString(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileOrder_result.class, metaDataMap); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public getFileOrder_result() { + } - 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.getMessage()); - } - } + public getFileOrder_result( + Map<Short, Integer> success) { + this(); + this.success = success; + } - private static class statusServer_argsStandardSchemeFactory implements SchemeFactory { - public statusServer_argsStandardScheme getScheme() { - return new statusServer_argsStandardScheme(); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getFileOrder_result(getFileOrder_result other) { + if (other.isSetSuccess()) { + Map<Short, Integer> __this__success = new HashMap<Short, Integer>(other.success.size()); + for (Map.Entry<Short, Integer> other_element : other.success.entrySet()) { - private static class statusServer_argsStandardScheme extends StandardScheme<statusServer_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, statusServer_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, statusServer_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + Short other_element_key = other_element.getKey(); + Integer other_element_value = other_element.getValue(); - } + Short __this__success_copy_key = other_element_key; - private static class statusServer_argsTupleSchemeFactory implements SchemeFactory { - public statusServer_argsTupleScheme getScheme() { - return new statusServer_argsTupleScheme(); - } - } + Integer __this__success_copy_value = other_element_value; - private static class statusServer_argsTupleScheme extends TupleScheme<statusServer_args> { + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, statusServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public getFileOrder_result deepCopy() { + return new getFileOrder_result(this); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, statusServer_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public void clear() { + this.success = null; + } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - public static class statusServer_result implements org.apache.thrift.TBase<statusServer_result, statusServer_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusServer_result"); + public void putToSuccess(short key, int val) { + if (this.success == null) { + this.success = new HashMap<Short, Integer>(); + } + this.success.put(key, val); + } - 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); + public Map<Short, Integer> getSuccess() { + return this.success; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new statusServer_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new statusServer_resultTupleSchemeFactory()); - } + public getFileOrder_result setSuccess(Map<Short, Integer> success) { + this.success = success; + return this; + } - public ServerStatus 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 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 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 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; - } - } + public void unsetSuccess() { + this.success = null; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ServerStatus.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusServer_result.class, metaDataMap); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public statusServer_result() { - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public statusServer_result( - ServerStatus success) - { - this(); - this.success = success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<Short, Integer>) value); + } + break; - /** - * Performs a deep copy on <i>other</i>. - */ - public statusServer_result(statusServer_result other) { - if (other.isSetSuccess()) { - this.success = new ServerStatus(other.success); - } - } + } + } - public statusServer_result deepCopy() { - return new statusServer_result(this); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - @Override - public void clear() { - this.success = null; - } + } + throw new IllegalStateException(); + } - public ServerStatus getSuccess() { - return this.success; - } + /** 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(); + } - public statusServer_result setSuccess(ServerStatus success) { - this.success = success; - return this; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public void unsetSuccess() { - this.success = null; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getFileOrder_result) + return this.equals((getFileOrder_result) that); + return false; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public boolean equals(getFileOrder_result that) { + if (that == null) + return false; - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + 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; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((ServerStatus)value); + return true; } - break; - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - } - throw new IllegalStateException(); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + return list.hashCode(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof statusServer_result) - return this.equals((statusServer_result)that); - return false; - } + @Override + public int compareTo(getFileOrder_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public boolean equals(statusServer_result that) { - if (that == null) - return false; + int lastComparison = 0; - 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; - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - return true; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int compareTo(statusServer_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - statusServer_result typedOther = (statusServer_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getFileOrder_result("); + boolean first = true; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - 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("statusServer_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 + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static class getFileOrder_resultStandardSchemeFactory implements SchemeFactory { + public getFileOrder_resultStandardScheme getScheme() { + return new getFileOrder_resultStandardScheme(); + } + } - private static class statusServer_resultStandardSchemeFactory implements SchemeFactory { - public statusServer_resultStandardScheme getScheme() { - return new statusServer_resultStandardScheme(); - } - } + private static class getFileOrder_resultStandardScheme extends StandardScheme<getFileOrder_result> { - private static class statusServer_resultStandardScheme extends StandardScheme<statusServer_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, statusServer_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 ServerStatus(); - struct.success.read(iprot); - 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, statusServer_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getFileOrder_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 _map248 = iprot.readMapBegin(); + struct.success = new HashMap<Short, Integer>(2 * _map248.size); + short _key249; + int _val250; + for (int _i251 = 0; _i251 < _map248.size; ++_i251) { + _key249 = iprot.readI16(); + _val250 = iprot.readI32(); + struct.success.put(_key249, _val250); + } + iprot.readMapEnd(); + } + 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(); + } - private static class statusServer_resultTupleSchemeFactory implements SchemeFactory { - public statusServer_resultTupleScheme getScheme() { - return new statusServer_resultTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getFileOrder_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class statusServer_resultTupleScheme extends TupleScheme<statusServer_result> { + 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.I16, org.apache.thrift.protocol.TType.I32, struct.success.size())); + for (Map.Entry<Short, Integer> _iter252 : struct.success.entrySet()) { + oprot.writeI16(_iter252.getKey()); + oprot.writeI32(_iter252.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, statusServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, statusServer_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new ServerStatus(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + private static class getFileOrder_resultTupleSchemeFactory implements SchemeFactory { + public getFileOrder_resultTupleScheme getScheme() { + return new getFileOrder_resultTupleScheme(); + } } - } - } - } + private static class getFileOrder_resultTupleScheme extends TupleScheme<getFileOrder_result> { - public static class freeSpace_args implements org.apache.thrift.TBase<freeSpace_args, freeSpace_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("freeSpace_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getFileOrder_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<Short, Integer> _iter253 : struct.success.entrySet()) { + oprot.writeI16(_iter253.getKey()); + oprot.writeI32(_iter253.getValue()); + } + } + } + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getFileOrder_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map254 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I16, org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.success = new HashMap<Short, Integer>(2 * _map254.size); + short _key255; + int _val256; + for (int _i257 = 0; _i257 < _map254.size; ++_i257) { + _key255 = iprot.readI16(); + _val256 = iprot.readI32(); + struct.success.put(_key255, _val256); + } + } + struct.setSuccessIsSet(true); + } + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new freeSpace_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new freeSpace_argsTupleSchemeFactory()); } + public static class generateAndAddPackages_args implements org.apache.thrift.TBase<generateAndAddPackages_args, generateAndAddPackages_args._Fields>, java.io.Serializable, Cloneable, Comparable<generateAndAddPackages_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generateAndAddPackages_args"); - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { -; - - 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(freeSpace_args.class, metaDataMap); - } - - public freeSpace_args() { - } + private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short) 1); + private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short) 2); - /** - * Performs a deep copy on <i>other</i>. - */ - public freeSpace_args(freeSpace_args other) { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public freeSpace_args deepCopy() { - return new freeSpace_args(this); - } + static { + schemes.put(StandardScheme.class, new generateAndAddPackages_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new generateAndAddPackages_argsTupleSchemeFactory()); + } - @Override - public void clear() { - } + public List<String> links; // required + /** + * + * @see Destination + */ + public Destination dest; // required - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(links); + out.writeInt(dest.getValue()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int describeContents() { + return 0; + } - /** 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(); - } + public generateAndAddPackages_args(android.os.Parcel in) { + this.links = new ArrayList<String>(); + in.readList(this.links, generateAndAddPackages_args.class.getClassLoader()); + this.dest = Destination.findByValue(in.readInt()); + } - switch (field) { - } - throw new IllegalStateException(); - } + public static final android.os.Parcelable.Creator<generateAndAddPackages_args> CREATOR = new android.os.Parcelable.Creator<generateAndAddPackages_args>() { + @Override + public generateAndAddPackages_args[] newArray(int size) { + return new generateAndAddPackages_args[size]; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof freeSpace_args) - return this.equals((freeSpace_args)that); - return false; - } + @Override + public generateAndAddPackages_args createFromParcel(android.os.Parcel in) { + return new generateAndAddPackages_args(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + LINKS((short) 1, "links"), + /** + * + * @see Destination + */ + DEST((short) 2, "dest"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public boolean equals(freeSpace_args that) { - if (that == null) - return false; + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // LINKS + return LINKS; + case 2: // DEST + return DEST; + default: + return null; + } + } - return true; - } + /** + * 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; + } - @Override - public int hashCode() { - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public int compareTo(freeSpace_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + private final short _thriftId; + private final String _fieldName; - int lastComparison = 0; - freeSpace_args typedOther = (freeSpace_args)other; + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - return 0; - } + public short getThriftFieldId() { + return _thriftId; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public String getFieldName() { + return _fieldName; + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generateAndAddPackages_args.class, metaDataMap); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("freeSpace_args("); - boolean first = true; + public generateAndAddPackages_args() { + } - sb.append(")"); - return sb.toString(); - } + public generateAndAddPackages_args( + List<String> links, + Destination dest) { + this(); + this.links = links; + this.dest = dest; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** + * Performs a deep copy on <i>other</i>. + */ + public generateAndAddPackages_args(generateAndAddPackages_args other) { + if (other.isSetLinks()) { + this.links = other.links; + } + if (other.isSetDest()) { + this.dest = other.dest; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public generateAndAddPackages_args deepCopy() { + return new generateAndAddPackages_args(this); + } - 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.getMessage()); - } - } + @Override + public void clear() { + this.links = null; + this.dest = null; + } - private static class freeSpace_argsStandardSchemeFactory implements SchemeFactory { - public freeSpace_argsStandardScheme getScheme() { - return new freeSpace_argsStandardScheme(); - } - } + public int getLinksSize() { + return (this.links == null) ? 0 : this.links.size(); + } - private static class freeSpace_argsStandardScheme extends StandardScheme<freeSpace_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, freeSpace_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, freeSpace_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public java.util.Iterator<String> getLinksIterator() { + return (this.links == null) ? null : this.links.iterator(); + } - } + public void addToLinks(String elem) { + if (this.links == null) { + this.links = new ArrayList<String>(); + } + this.links.add(elem); + } - private static class freeSpace_argsTupleSchemeFactory implements SchemeFactory { - public freeSpace_argsTupleScheme getScheme() { - return new freeSpace_argsTupleScheme(); - } - } + public List<String> getLinks() { + return this.links; + } - private static class freeSpace_argsTupleScheme extends TupleScheme<freeSpace_args> { + public generateAndAddPackages_args setLinks(List<String> links) { + this.links = links; + return this; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, freeSpace_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public void unsetLinks() { + this.links = null; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, freeSpace_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + /** Returns true if field links is set (has been assigned a value) and false otherwise */ + public boolean isSetLinks() { + return this.links != null; + } - } + public void setLinksIsSet(boolean value) { + if (!value) { + this.links = null; + } + } - public static class freeSpace_result implements org.apache.thrift.TBase<freeSpace_result, freeSpace_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("freeSpace_result"); + /** + * + * @see Destination + */ + public Destination getDest() { + return this.dest; + } - 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); + /** + * + * @see Destination + */ + public generateAndAddPackages_args setDest(Destination dest) { + this.dest = dest; + return this; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new freeSpace_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new freeSpace_resultTupleSchemeFactory()); - } + public void unsetDest() { + this.dest = null; + } - public long 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 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 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 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; - } - } + /** Returns true if field dest is set (has been assigned a value) and false otherwise */ + public boolean isSetDest() { + return this.dest != null; + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(freeSpace_result.class, metaDataMap); - } + public void setDestIsSet(boolean value) { + if (!value) { + this.dest = null; + } + } - public freeSpace_result() { - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case LINKS: + if (value == null) { + unsetLinks(); + } else { + setLinks((List<String>) value); + } + break; - public freeSpace_result( - long success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + case DEST: + if (value == null) { + unsetDest(); + } else { + setDest((Destination) value); + } + break; - /** - * Performs a deep copy on <i>other</i>. - */ - public freeSpace_result(freeSpace_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + } + } - public freeSpace_result deepCopy() { - return new freeSpace_result(this); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case LINKS: + return getLinks(); - @Override - public void clear() { - setSuccessIsSet(false); - this.success = 0; - } + case DEST: + return getDest(); - public long getSuccess() { - return this.success; - } + } + throw new IllegalStateException(); + } - public freeSpace_result setSuccess(long success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + /** 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(); + } - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + switch (field) { + case LINKS: + return isSetLinks(); + case DEST: + return isSetDest(); + } + throw new IllegalStateException(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof generateAndAddPackages_args) + return this.equals((generateAndAddPackages_args) that); + return false; + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + public boolean equals(generateAndAddPackages_args that) { + if (that == null) + return false; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Long)value); - } - break; + boolean this_present_links = true && this.isSetLinks(); + boolean that_present_links = true && that.isSetLinks(); + if (this_present_links || that_present_links) { + if (!(this_present_links && that_present_links)) + return false; + if (!this.links.equals(that.links)) + return false; + } - } - } + boolean this_present_dest = true && this.isSetDest(); + boolean that_present_dest = true && that.isSetDest(); + if (this_present_dest || that_present_dest) { + if (!(this_present_dest && that_present_dest)) + return false; + if (!this.dest.equals(that.dest)) + return false; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Long.valueOf(getSuccess()); + return true; + } - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + boolean present_links = true && (isSetLinks()); + list.add(present_links); + if (present_links) + list.add(links); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof freeSpace_result) - return this.equals((freeSpace_result)that); - return false; - } + boolean present_dest = true && (isSetDest()); + list.add(present_dest); + if (present_dest) + list.add(dest.getValue()); - public boolean equals(freeSpace_result that) { - if (that == null) - return false; + return list.hashCode(); + } - 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; - } + @Override + public int compareTo(generateAndAddPackages_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - return true; - } + int lastComparison = 0; - @Override - public int hashCode() { - return 0; - } + lastComparison = Boolean.valueOf(isSetLinks()).compareTo(other.isSetLinks()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinks()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, other.links); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDest()).compareTo(other.isSetDest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, other.dest); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public int compareTo(freeSpace_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - freeSpace_result typedOther = (freeSpace_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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 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); + } - 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("generateAndAddPackages_args("); + boolean first = true; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("freeSpace_result("); - boolean first = true; + sb.append("links:"); + if (this.links == null) { + sb.append("null"); + } else { + sb.append(this.links); + } + first = false; + if (!first) sb.append(", "); + sb.append("dest:"); + if (this.dest == null) { + sb.append("null"); + } else { + sb.append(this.dest); + } + first = false; + sb.append(")"); + return sb.toString(); + } - sb.append("success:"); - 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 + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static class generateAndAddPackages_argsStandardSchemeFactory implements SchemeFactory { + public generateAndAddPackages_argsStandardScheme getScheme() { + return new generateAndAddPackages_argsStandardScheme(); + } + } - private static class freeSpace_resultStandardSchemeFactory implements SchemeFactory { - public freeSpace_resultStandardScheme getScheme() { - return new freeSpace_resultStandardScheme(); - } - } + private static class generateAndAddPackages_argsStandardScheme extends StandardScheme<generateAndAddPackages_args> { - private static class freeSpace_resultStandardScheme extends StandardScheme<freeSpace_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, freeSpace_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; - 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, freeSpace_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeI64(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, generateAndAddPackages_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: // LINKS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list258 = iprot.readListBegin(); + struct.links = new ArrayList<String>(_list258.size); + String _elem259; + for (int _i260 = 0; _i260 < _list258.size; ++_i260) { + _elem259 = iprot.readString(); + struct.links.add(_elem259); + } + iprot.readListEnd(); + } + struct.setLinksIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DEST + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(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(); + } - private static class freeSpace_resultTupleSchemeFactory implements SchemeFactory { - public freeSpace_resultTupleScheme getScheme() { - return new freeSpace_resultTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, generateAndAddPackages_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class freeSpace_resultTupleScheme extends TupleScheme<freeSpace_result> { + oprot.writeStructBegin(STRUCT_DESC); + if (struct.links != null) { + oprot.writeFieldBegin(LINKS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); + for (String _iter261 : struct.links) { + oprot.writeString(_iter261); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.dest != null) { + oprot.writeFieldBegin(DEST_FIELD_DESC); + oprot.writeI32(struct.dest.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, freeSpace_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeI64(struct.success); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, freeSpace_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readI64(); - struct.setSuccessIsSet(true); + private static class generateAndAddPackages_argsTupleSchemeFactory implements SchemeFactory { + public generateAndAddPackages_argsTupleScheme getScheme() { + return new generateAndAddPackages_argsTupleScheme(); + } } - } - } - } + private static class generateAndAddPackages_argsTupleScheme extends TupleScheme<generateAndAddPackages_args> { - public static class getServerVersion_args implements org.apache.thrift.TBase<getServerVersion_args, getServerVersion_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServerVersion_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetLinks()) { + optionals.set(0); + } + if (struct.isSetDest()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetLinks()) { + { + oprot.writeI32(struct.links.size()); + for (String _iter262 : struct.links) { + oprot.writeString(_iter262); + } + } + } + if (struct.isSetDest()) { + oprot.writeI32(struct.dest.getValue()); + } + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list263 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.links = new ArrayList<String>(_list263.size); + String _elem264; + for (int _i265 = 0; _i265 < _list263.size; ++_i265) { + _elem264 = iprot.readString(); + struct.links.add(_elem264); + } + } + struct.setLinksIsSet(true); + } + if (incoming.get(1)) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(true); + } + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getServerVersion_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getServerVersion_argsTupleSchemeFactory()); } + public static class generateAndAddPackages_result implements org.apache.thrift.TBase<generateAndAddPackages_result, generateAndAddPackages_result._Fields>, java.io.Serializable, Cloneable, Comparable<generateAndAddPackages_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generateAndAddPackages_result"); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServerVersion_args.class, metaDataMap); - } - - public getServerVersion_args() { - } + 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); - /** - * Performs a deep copy on <i>other</i>. - */ - public getServerVersion_args(getServerVersion_args other) { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public getServerVersion_args deepCopy() { - return new getServerVersion_args(this); - } + static { + schemes.put(StandardScheme.class, new generateAndAddPackages_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new generateAndAddPackages_resultTupleSchemeFactory()); + } - @Override - public void clear() { - } + public List<Integer> success; // required - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(success); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int describeContents() { + return 0; + } - /** 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(); - } + public generateAndAddPackages_result(android.os.Parcel in) { + this.success = new ArrayList<Integer>(); + in.readList(this.success, generateAndAddPackages_result.class.getClassLoader()); + } - switch (field) { - } - throw new IllegalStateException(); - } + public static final android.os.Parcelable.Creator<generateAndAddPackages_result> CREATOR = new android.os.Parcelable.Creator<generateAndAddPackages_result>() { + @Override + public generateAndAddPackages_result[] newArray(int size) { + return new generateAndAddPackages_result[size]; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getServerVersion_args) - return this.equals((getServerVersion_args)that); - return false; - } + @Override + public generateAndAddPackages_result createFromParcel(android.os.Parcel in) { + return new generateAndAddPackages_result(in); + } + }; - public boolean equals(getServerVersion_args that) { - if (that == null) - return false; + /** 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"); - return true; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public int hashCode() { - return 0; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int compareTo(getServerVersion_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - int lastComparison = 0; - getServerVersion_args typedOther = (getServerVersion_args)other; + /** + * 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; + } - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private final short _thriftId; + private final String _fieldName; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getServerVersion_args("); - boolean first = true; + public String getFieldName() { + return _fieldName; + } + } - sb.append(")"); - return sb.toString(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generateAndAddPackages_result.class, metaDataMap); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public generateAndAddPackages_result() { + } - 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.getMessage()); - } - } + public generateAndAddPackages_result( + List<Integer> success) { + this(); + this.success = success; + } - private static class getServerVersion_argsStandardSchemeFactory implements SchemeFactory { - public getServerVersion_argsStandardScheme getScheme() { - return new getServerVersion_argsStandardScheme(); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public generateAndAddPackages_result(generateAndAddPackages_result other) { + if (other.isSetSuccess()) { + List<Integer> __this__success = new ArrayList<Integer>(other.success.size()); + for (Integer other_element : other.success) { + __this__success.add(other_element); + } + this.success = __this__success; + } + } - private static class getServerVersion_argsStandardScheme extends StandardScheme<getServerVersion_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getServerVersion_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, getServerVersion_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public generateAndAddPackages_result deepCopy() { + return new generateAndAddPackages_result(this); + } - } + @Override + public void clear() { + this.success = null; + } - private static class getServerVersion_argsTupleSchemeFactory implements SchemeFactory { - public getServerVersion_argsTupleScheme getScheme() { - return new getServerVersion_argsTupleScheme(); - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - private static class getServerVersion_argsTupleScheme extends TupleScheme<getServerVersion_args> { + public java.util.Iterator<Integer> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getServerVersion_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public void addToSuccess(int elem) { + if (this.success == null) { + this.success = new ArrayList<Integer>(); + } + this.success.add(elem); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getServerVersion_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public List<Integer> getSuccess() { + return this.success; + } - } + public generateAndAddPackages_result setSuccess(List<Integer> success) { + this.success = success; + return this; + } - public static class getServerVersion_result implements org.apache.thrift.TBase<getServerVersion_result, getServerVersion_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServerVersion_result"); + public void unsetSuccess() { + this.success = null; + } - 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); + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getServerVersion_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getServerVersion_resultTupleSchemeFactory()); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public 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 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 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 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; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<Integer>) value); + } + break; - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServerVersion_result.class, metaDataMap); - } + } + } - public getServerVersion_result() { - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public getServerVersion_result( - String success) - { - this(); - this.success = success; - } + } + throw new IllegalStateException(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getServerVersion_result(getServerVersion_result other) { - if (other.isSetSuccess()) { - this.success = other.success; - } - } + /** 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(); + } - public getServerVersion_result deepCopy() { - return new getServerVersion_result(this); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - @Override - public void clear() { - this.success = null; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof generateAndAddPackages_result) + return this.equals((generateAndAddPackages_result) that); + return false; + } - public String getSuccess() { - return this.success; - } + public boolean equals(generateAndAddPackages_result that) { + if (that == null) + return false; - public getServerVersion_result setSuccess(String success) { - this.success = success; - return this; - } + 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; + } - public void unsetSuccess() { - this.success = null; - } + return true; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((String)value); + return list.hashCode(); } - break; - } - } + @Override + public int compareTo(generateAndAddPackages_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + int lastComparison = 0; - } - throw new IllegalStateException(); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getServerVersion_result) - return this.equals((getServerVersion_result)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public boolean equals(getServerVersion_result that) { - if (that == null) - return false; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - 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; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("generateAndAddPackages_result("); + boolean first = true; - return true; - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public int hashCode() { - return 0; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public int compareTo(getServerVersion_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getServerVersion_result typedOther = (getServerVersion_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class generateAndAddPackages_resultStandardSchemeFactory implements SchemeFactory { + public generateAndAddPackages_resultStandardScheme getScheme() { + return new generateAndAddPackages_resultStandardScheme(); + } + } - 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("getServerVersion_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(); - } + private static class generateAndAddPackages_resultStandardScheme extends StandardScheme<generateAndAddPackages_result> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot, generateAndAddPackages_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 _list266 = iprot.readListBegin(); + struct.success = new ArrayList<Integer>(_list266.size); + int _elem267; + for (int _i268 = 0; _i268 < _list266.size; ++_i268) { + _elem267 = iprot.readI32(); + struct.success.add(_elem267); + } + iprot.readListEnd(); + } + 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(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, generateAndAddPackages_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class getServerVersion_resultStandardSchemeFactory implements SchemeFactory { - public getServerVersion_resultStandardScheme getScheme() { - return new getServerVersion_resultStandardScheme(); - } - } + 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.I32, struct.success.size())); + for (int _iter269 : struct.success) { + oprot.writeI32(_iter269); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class getServerVersion_resultStandardScheme extends StandardScheme<getServerVersion_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getServerVersion_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, getServerVersion_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 generateAndAddPackages_resultTupleSchemeFactory implements SchemeFactory { + public generateAndAddPackages_resultTupleScheme getScheme() { + return new generateAndAddPackages_resultTupleScheme(); + } + } - private static class getServerVersion_resultTupleSchemeFactory implements SchemeFactory { - public getServerVersion_resultTupleScheme getScheme() { - return new getServerVersion_resultTupleScheme(); - } - } + private static class generateAndAddPackages_resultTupleScheme extends TupleScheme<generateAndAddPackages_result> { - private static class getServerVersion_resultTupleScheme extends TupleScheme<getServerVersion_result> { + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (int _iter270 : struct.success) { + oprot.writeI32(_iter270); + } + } + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getServerVersion_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new 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, generateAndAddPackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list271 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.success = new ArrayList<Integer>(_list271.size); + int _elem272; + for (int _i273 = 0; _i273 < _list271.size; ++_i273) { + _elem272 = iprot.readI32(); + struct.success.add(_elem272); + } + } + struct.setSuccessIsSet(true); + } + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getServerVersion_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readString(); - struct.setSuccessIsSet(true); - } - } } - } - - public static class kill_args implements org.apache.thrift.TBase<kill_args, kill_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("kill_args"); + public static class addPackage_args implements org.apache.thrift.TBase<addPackage_args, addPackage_args._Fields>, java.io.Serializable, Cloneable, Comparable<addPackage_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addPackage_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.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short) 2); + private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short) 3); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new kill_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new kill_argsTupleSchemeFactory()); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + static { + schemes.put(StandardScheme.class, new addPackage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new addPackage_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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(kill_args.class, metaDataMap); - } + public String name; // required + public List<String> links; // required + /** + * + * @see Destination + */ + public Destination dest; // required - public kill_args() { - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(name); + out.writeList(links); + out.writeInt(dest.getValue()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public kill_args(kill_args other) { - } + @Override + public int describeContents() { + return 0; + } - public kill_args deepCopy() { - return new kill_args(this); - } + public addPackage_args(android.os.Parcel in) { + this.name = in.readString(); + this.links = new ArrayList<String>(); + in.readList(this.links, addPackage_args.class.getClassLoader()); + this.dest = Destination.findByValue(in.readInt()); + } - @Override - public void clear() { - } + public static final android.os.Parcelable.Creator<addPackage_args> CREATOR = new android.os.Parcelable.Creator<addPackage_args>() { + @Override + public addPackage_args[] newArray(int size) { + return new addPackage_args[size]; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public addPackage_args createFromParcel(android.os.Parcel in) { + return new addPackage_args(in); + } + }; + + /** 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"), + LINKS((short) 2, "links"), + /** + * + * @see Destination + */ + DEST((short) 3, "dest"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + /** + * 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: // LINKS + return LINKS; + case 3: // DEST + return DEST; + default: + return null; + } + } - /** 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(); - } + /** + * 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; + } - switch (field) { - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof kill_args) - return this.equals((kill_args)that); - return false; - } + private final short _thriftId; + private final String _fieldName; - public boolean equals(kill_args that) { - if (that == null) - return false; + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - return true; - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public int hashCode() { - return 0; - } + public String getFieldName() { + return _fieldName; + } + } - public int compareTo(kill_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - int lastComparison = 0; - kill_args typedOther = (kill_args)other; + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addPackage_args.class, metaDataMap); + } - return 0; - } + public addPackage_args() { + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public addPackage_args( + String name, + List<String> links, + Destination dest) { + this(); + this.name = name; + this.links = links; + this.dest = dest; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public addPackage_args(addPackage_args other) { + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetLinks()) { + this.links = other.links; + } + if (other.isSetDest()) { + this.dest = other.dest; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public addPackage_args deepCopy() { + return new addPackage_args(this); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("kill_args("); - boolean first = true; + @Override + public void clear() { + this.name = null; + this.links = null; + this.dest = null; + } - sb.append(")"); - return sb.toString(); - } + public String getName() { + return this.name; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public addPackage_args setName(String name) { + this.name = name; + return this; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void unsetName() { + this.name = null; + } - 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.getMessage()); - } - } + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } - private static class kill_argsStandardSchemeFactory implements SchemeFactory { - public kill_argsStandardScheme getScheme() { - return new kill_argsStandardScheme(); - } - } + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } - private static class kill_argsStandardScheme extends StandardScheme<kill_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, kill_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, kill_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public int getLinksSize() { + return (this.links == null) ? 0 : this.links.size(); + } - } + public java.util.Iterator<String> getLinksIterator() { + return (this.links == null) ? null : this.links.iterator(); + } - private static class kill_argsTupleSchemeFactory implements SchemeFactory { - public kill_argsTupleScheme getScheme() { - return new kill_argsTupleScheme(); - } - } + public void addToLinks(String elem) { + if (this.links == null) { + this.links = new ArrayList<String>(); + } + this.links.add(elem); + } - private static class kill_argsTupleScheme extends TupleScheme<kill_args> { + public List<String> getLinks() { + return this.links; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, kill_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public addPackage_args setLinks(List<String> links) { + this.links = links; + return this; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, kill_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public void unsetLinks() { + this.links = null; + } - } + /** Returns true if field links is set (has been assigned a value) and false otherwise */ + public boolean isSetLinks() { + return this.links != null; + } - public static class kill_result implements org.apache.thrift.TBase<kill_result, kill_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("kill_result"); + public void setLinksIsSet(boolean value) { + if (!value) { + this.links = null; + } + } + /** + * + * @see Destination + */ + public Destination getDest() { + return this.dest; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new kill_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new kill_resultTupleSchemeFactory()); - } + /** + * + * @see Destination + */ + public addPackage_args setDest(Destination dest) { + this.dest = dest; + return this; + } + public void unsetDest() { + this.dest = null; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(kill_result.class, metaDataMap); - } + /** Returns true if field dest is set (has been assigned a value) and false otherwise */ + public boolean isSetDest() { + return this.dest != null; + } - public kill_result() { - } + public void setDestIsSet(boolean value) { + if (!value) { + this.dest = null; + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public kill_result(kill_result other) { - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; - public kill_result deepCopy() { - return new kill_result(this); - } + case LINKS: + if (value == null) { + unsetLinks(); + } else { + setLinks((List<String>) value); + } + break; - @Override - public void clear() { - } + case DEST: + if (value == null) { + unsetDest(); + } else { + setDest((Destination) value); + } + break; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); - /** 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(); - } + case LINKS: + return getLinks(); - switch (field) { - } - throw new IllegalStateException(); - } + case DEST: + return getDest(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof kill_result) - return this.equals((kill_result)that); - return false; - } + } + throw new IllegalStateException(); + } - public boolean equals(kill_result that) { - if (that == null) - return false; + /** 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(); + } - return true; - } + switch (field) { + case NAME: + return isSetName(); + case LINKS: + return isSetLinks(); + case DEST: + return isSetDest(); + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof addPackage_args) + return this.equals((addPackage_args) that); + return false; + } - public int compareTo(kill_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public boolean equals(addPackage_args that) { + if (that == null) + return false; - int lastComparison = 0; - kill_result typedOther = (kill_result)other; + 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 0; - } + boolean this_present_links = true && this.isSetLinks(); + boolean that_present_links = true && that.isSetLinks(); + if (this_present_links || that_present_links) { + if (!(this_present_links && that_present_links)) + return false; + if (!this.links.equals(that.links)) + return false; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + boolean this_present_dest = true && this.isSetDest(); + boolean that_present_dest = true && that.isSetDest(); + if (this_present_dest || that_present_dest) { + if (!(this_present_dest && that_present_dest)) + return false; + if (!this.dest.equals(that.dest)) + return false; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return true; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("kill_result("); - boolean first = true; + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); - sb.append(")"); - return sb.toString(); - } + boolean present_links = true && (isSetLinks()); + list.add(present_links); + if (present_links) + list.add(links); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + boolean present_dest = true && (isSetDest()); + list.add(present_dest); + if (present_dest) + list.add(dest.getValue()); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return list.hashCode(); + } - 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.getMessage()); - } - } + @Override + public int compareTo(addPackage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class kill_resultStandardSchemeFactory implements SchemeFactory { - public kill_resultStandardScheme getScheme() { - return new kill_resultStandardScheme(); - } - } + int lastComparison = 0; - private static class kill_resultStandardScheme extends StandardScheme<kill_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, kill_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) { - 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, kill_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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(isSetLinks()).compareTo(other.isSetLinks()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinks()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, other.links); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetDest()).compareTo(other.isSetDest()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDest()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, other.dest); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class kill_resultTupleSchemeFactory implements SchemeFactory { - public kill_resultTupleScheme getScheme() { - return new kill_resultTupleScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class kill_resultTupleScheme extends TupleScheme<kill_result> { + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, kill_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("addPackage_args("); + boolean first = true; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, kill_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("links:"); + if (this.links == null) { + sb.append("null"); + } else { + sb.append(this.links); + } + first = false; + if (!first) sb.append(", "); + sb.append("dest:"); + if (this.dest == null) { + sb.append("null"); + } else { + sb.append(this.dest); + } + first = false; + sb.append(")"); + return sb.toString(); + } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public static class restart_args implements org.apache.thrift.TBase<restart_args, restart_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restart_args"); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(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 final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restart_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restart_argsTupleSchemeFactory()); - } + private static class addPackage_argsStandardSchemeFactory implements SchemeFactory { + public addPackage_argsStandardScheme getScheme() { + return new addPackage_argsStandardScheme(); + } + } + private static class addPackage_argsStandardScheme extends StandardScheme<addPackage_args> { - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { -; - - 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restart_args.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, addPackage_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; + case 2: // LINKS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list274 = iprot.readListBegin(); + struct.links = new ArrayList<String>(_list274.size); + String _elem275; + for (int _i276 = 0; _i276 < _list274.size; ++_i276) { + _elem275 = iprot.readString(); + struct.links.add(_elem275); + } + iprot.readListEnd(); + } + struct.setLinksIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // DEST + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(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(); - public restart_args() { - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public restart_args(restart_args other) { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, addPackage_args struct) throws org.apache.thrift.TException { + struct.validate(); - public restart_args deepCopy() { - return new restart_args(this); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + if (struct.links != null) { + oprot.writeFieldBegin(LINKS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); + for (String _iter277 : struct.links) { + oprot.writeString(_iter277); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + if (struct.dest != null) { + oprot.writeFieldBegin(DEST_FIELD_DESC); + oprot.writeI32(struct.dest.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void clear() { - } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class addPackage_argsTupleSchemeFactory implements SchemeFactory { + public addPackage_argsTupleScheme getScheme() { + return new addPackage_argsTupleScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static class addPackage_argsTupleScheme extends TupleScheme<addPackage_args> { - /** 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(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, addPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetLinks()) { + optionals.set(1); + } + if (struct.isSetDest()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetLinks()) { + { + oprot.writeI32(struct.links.size()); + for (String _iter278 : struct.links) { + oprot.writeString(_iter278); + } + } + } + if (struct.isSetDest()) { + oprot.writeI32(struct.dest.getValue()); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, addPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + { + org.apache.thrift.protocol.TList _list279 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.links = new ArrayList<String>(_list279.size); + String _elem280; + for (int _i281 = 0; _i281 < _list279.size; ++_i281) { + _elem280 = iprot.readString(); + struct.links.add(_elem280); + } + } + struct.setLinksIsSet(true); + } + if (incoming.get(2)) { + struct.dest = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestIsSet(true); + } + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restart_args) - return this.equals((restart_args)that); - return false; } - public boolean equals(restart_args that) { - if (that == null) - return false; + public static class addPackage_result implements org.apache.thrift.TBase<addPackage_result, addPackage_result._Fields>, java.io.Serializable, Cloneable, Comparable<addPackage_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addPackage_result"); - return true; - } + 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); - @Override - public int hashCode() { - return 0; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public int compareTo(restart_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + static { + schemes.put(StandardScheme.class, new addPackage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new addPackage_resultTupleSchemeFactory()); + } - int lastComparison = 0; - restart_args typedOther = (restart_args)other; + public int success; // required - return 0; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + out.writeInt(success); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int describeContents() { + return 0; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public addPackage_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restart_args("); - boolean first = true; + this.success = in.readInt(); + } - sb.append(")"); - return sb.toString(); - } + public static final android.os.Parcelable.Creator<addPackage_result> CREATOR = new android.os.Parcelable.Creator<addPackage_result>() { + @Override + public addPackage_result[] newArray(int size) { + return new addPackage_result[size]; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public addPackage_result createFromParcel(android.os.Parcel in) { + return new addPackage_result(in); + } + }; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** 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 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.getMessage()); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class restart_argsStandardSchemeFactory implements SchemeFactory { - public restart_argsStandardScheme getScheme() { - return new restart_argsStandardScheme(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class restart_argsStandardScheme extends StandardScheme<restart_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restart_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, restart_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + 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; + } - private static class restart_argsTupleSchemeFactory implements SchemeFactory { - public restart_argsTupleScheme getScheme() { - return new restart_argsTupleScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class restart_argsTupleScheme extends TupleScheme<restart_args> { + private final short _thriftId; + private final String _fieldName; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restart_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restart_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public short getThriftFieldId() { + return _thriftId; + } - } + public String getFieldName() { + return _fieldName; + } + } - public static class restart_result implements org.apache.thrift.TBase<restart_result, restart_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restart_result"); + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addPackage_result.class, metaDataMap); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restart_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restart_resultTupleSchemeFactory()); - } + public addPackage_result() { + } + public addPackage_result( + int success) { + this(); + this.success = success; + setSuccessIsSet(true); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restart_result.class, metaDataMap); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public addPackage_result(addPackage_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } - public restart_result() { - } + public addPackage_result deepCopy() { + return new addPackage_result(this); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public restart_result(restart_result other) { - } + @Override + public void clear() { + setSuccessIsSet(false); + this.success = 0; + } - public restart_result deepCopy() { - return new restart_result(this); - } + public int getSuccess() { + return this.success; + } - @Override - public void clear() { - } + public addPackage_result setSuccess(int success) { + this.success = success; + setSuccessIsSet(true); + return this; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - /** 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(); - } + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } - switch (field) { - } - throw new IllegalStateException(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Integer) value); + } + break; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restart_result) - return this.equals((restart_result)that); - return false; - } + } + } - public boolean equals(restart_result that) { - if (that == null) - return false; + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - return true; - } + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + /** 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(); + } - public int compareTo(restart_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - int lastComparison = 0; - restart_result typedOther = (restart_result)other; + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof addPackage_result) + return this.equals((addPackage_result) that); + return false; + } - return 0; - } + public boolean equals(addPackage_result that) { + if (that == null) + return false; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return true; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restart_result("); - boolean first = true; + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); - sb.append(")"); - return sb.toString(); - } + return list.hashCode(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int compareTo(addPackage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + int lastComparison = 0; - 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.getMessage()); - } - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - private static class restart_resultStandardSchemeFactory implements SchemeFactory { - public restart_resultStandardScheme getScheme() { - return new restart_resultStandardScheme(); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class restart_resultStandardScheme extends StandardScheme<restart_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restart_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) { - 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, restart_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class restart_resultTupleSchemeFactory implements SchemeFactory { - public restart_resultTupleScheme getScheme() { - return new restart_resultTupleScheme(); - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("addPackage_result("); + boolean first = true; - private static class restart_resultTupleScheme extends TupleScheme<restart_result> { + sb.append("success:"); + sb.append(this.success); + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restart_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restart_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public static class getLog_args implements org.apache.thrift.TBase<getLog_args, getLog_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLog_args"); + private static class addPackage_resultStandardSchemeFactory implements SchemeFactory { + public addPackage_resultStandardScheme getScheme() { + return new addPackage_resultStandardScheme(); + } + } - private static final org.apache.thrift.protocol.TField OFFSET_FIELD_DESC = new org.apache.thrift.protocol.TField("offset", org.apache.thrift.protocol.TType.I32, (short)1); + private static class addPackage_resultStandardScheme extends StandardScheme<addPackage_result> { - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getLog_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getLog_argsTupleSchemeFactory()); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, addPackage_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; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public int offset; // 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 { - OFFSET((short)1, "offset"); - - 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: // OFFSET - return OFFSET; - 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; - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - // isset id assignments - private static final int __OFFSET_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.OFFSET, new org.apache.thrift.meta_data.FieldMetaData("offset", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLog_args.class, metaDataMap); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, addPackage_result struct) throws org.apache.thrift.TException { + struct.validate(); - public getLog_args() { - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeI32(struct.success); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public getLog_args( - int offset) - { - this(); - this.offset = offset; - setOffsetIsSet(true); - } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getLog_args(getLog_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.offset = other.offset; - } + private static class addPackage_resultTupleSchemeFactory implements SchemeFactory { + public addPackage_resultTupleScheme getScheme() { + return new addPackage_resultTupleScheme(); + } + } - public getLog_args deepCopy() { - return new getLog_args(this); - } + private static class addPackage_resultTupleScheme extends TupleScheme<addPackage_result> { - @Override - public void clear() { - setOffsetIsSet(false); - this.offset = 0; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, addPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeI32(struct.success); + } + } - public int getOffset() { - return this.offset; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, addPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readI32(); + struct.setSuccessIsSet(true); + } + } + } - public getLog_args setOffset(int offset) { - this.offset = offset; - setOffsetIsSet(true); - return this; } - public void unsetOffset() { - __isset_bit_vector.clear(__OFFSET_ISSET_ID); - } + public static class addFiles_args implements org.apache.thrift.TBase<addFiles_args, addFiles_args._Fields>, java.io.Serializable, Cloneable, Comparable<addFiles_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addFiles_args"); - /** Returns true if field offset is set (has been assigned a value) and false otherwise */ - public boolean isSetOffset() { - return __isset_bit_vector.get(__OFFSET_ISSET_ID); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short) 2); - public void setOffsetIsSet(boolean value) { - __isset_bit_vector.set(__OFFSET_ISSET_ID, value); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case OFFSET: - if (value == null) { - unsetOffset(); - } else { - setOffset((Integer)value); + static { + schemes.put(StandardScheme.class, new addFiles_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new addFiles_argsTupleSchemeFactory()); } - break; - } - } + public int pid; // required + public List<String> links; // required - public Object getFieldValue(_Fields field) { - switch (field) { - case OFFSET: - return Integer.valueOf(getOffset()); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - } - throw new IllegalStateException(); - } + out.writeInt(pid); + out.writeList(links); + } - /** 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 OFFSET: - return isSetOffset(); - } - throw new IllegalStateException(); - } + @Override + public int describeContents() { + return 0; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getLog_args) - return this.equals((getLog_args)that); - return false; - } + public addFiles_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public boolean equals(getLog_args that) { - if (that == null) - return false; + this.pid = in.readInt(); + this.links = new ArrayList<String>(); + in.readList(this.links, addFiles_args.class.getClassLoader()); + } - boolean this_present_offset = true; - boolean that_present_offset = true; - if (this_present_offset || that_present_offset) { - if (!(this_present_offset && that_present_offset)) - return false; - if (this.offset != that.offset) - return false; - } + public static final android.os.Parcelable.Creator<addFiles_args> CREATOR = new android.os.Parcelable.Creator<addFiles_args>() { + @Override + public addFiles_args[] newArray(int size) { + return new addFiles_args[size]; + } - return true; - } + @Override + public addFiles_args createFromParcel(android.os.Parcel in) { + return new addFiles_args(in); + } + }; - @Override - public int hashCode() { - return 0; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"), + LINKS((short) 2, "links"); - public int compareTo(getLog_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getLog_args typedOther = (getLog_args)other; - - lastComparison = Boolean.valueOf(isSetOffset()).compareTo(typedOther.isSetOffset()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOffset()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.offset, typedOther.offset); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + case 2: // LINKS + return LINKS; + default: + return null; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** + * 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; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getLog_args("); - boolean first = true; + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - sb.append("offset:"); - sb.append(this.offset); - first = false; - sb.append(")"); - return sb.toString(); - } + private final short _thriftId; + private final String _fieldName; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class getLog_argsStandardSchemeFactory implements SchemeFactory { - public getLog_argsStandardScheme getScheme() { - return new getLog_argsStandardScheme(); - } - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class getLog_argsStandardScheme extends StandardScheme<getLog_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getLog_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: // OFFSET - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.offset = iprot.readI32(); - struct.setOffsetIsSet(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, getLog_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(OFFSET_FIELD_DESC); - oprot.writeI32(struct.offset); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST, "LinkList"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addFiles_args.class, metaDataMap); + } - } + public addFiles_args() { + } - private static class getLog_argsTupleSchemeFactory implements SchemeFactory { - public getLog_argsTupleScheme getScheme() { - return new getLog_argsTupleScheme(); - } - } + public addFiles_args( + int pid, + List<String> links) { + this(); + this.pid = pid; + setPidIsSet(true); + this.links = links; + } - private static class getLog_argsTupleScheme extends TupleScheme<getLog_args> { + /** + * Performs a deep copy on <i>other</i>. + */ + public addFiles_args(addFiles_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + if (other.isSetLinks()) { + this.links = other.links; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getLog_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetOffset()) { - optionals.set(0); + public addFiles_args deepCopy() { + return new addFiles_args(this); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetOffset()) { - oprot.writeI32(struct.offset); + + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + this.links = null; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getLog_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.offset = iprot.readI32(); - struct.setOffsetIsSet(true); + public int getPid() { + return this.pid; } - } - } - } + public addFiles_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public static class getLog_result implements org.apache.thrift.TBase<getLog_result, getLog_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getLog_result"); + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - 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); + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getLog_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getLog_resultTupleSchemeFactory()); - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - public List<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 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 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 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; - } - } + public int getLinksSize() { + return (this.links == null) ? 0 : this.links.size(); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getLog_result.class, metaDataMap); - } + public java.util.Iterator<String> getLinksIterator() { + return (this.links == null) ? null : this.links.iterator(); + } - public getLog_result() { - } + public void addToLinks(String elem) { + if (this.links == null) { + this.links = new ArrayList<String>(); + } + this.links.add(elem); + } - public getLog_result( - List<String> success) - { - this(); - this.success = success; - } + public List<String> getLinks() { + return this.links; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getLog_result(getLog_result other) { - if (other.isSetSuccess()) { - List<String> __this__success = new ArrayList<String>(); - for (String other_element : other.success) { - __this__success.add(other_element); - } - this.success = __this__success; - } - } + public addFiles_args setLinks(List<String> links) { + this.links = links; + return this; + } - public getLog_result deepCopy() { - return new getLog_result(this); - } + public void unsetLinks() { + this.links = null; + } - @Override - public void clear() { - this.success = null; - } + /** Returns true if field links is set (has been assigned a value) and false otherwise */ + public boolean isSetLinks() { + return this.links != null; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public void setLinksIsSet(boolean value) { + if (!value) { + this.links = null; + } + } - public java.util.Iterator<String> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - public void addToSuccess(String elem) { - if (this.success == null) { - this.success = new ArrayList<String>(); - } - this.success.add(elem); - } + case LINKS: + if (value == null) { + unsetLinks(); + } else { + setLinks((List<String>) value); + } + break; - public List<String> getSuccess() { - return this.success; - } + } + } - public getLog_result setSuccess(List<String> success) { - this.success = success; - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - public void unsetSuccess() { - this.success = null; - } + case LINKS: + return getLinks(); - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + } + throw new IllegalStateException(); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<String>)value); + switch (field) { + case PID: + return isSetPid(); + case LINKS: + return isSetLinks(); + } + throw new IllegalStateException(); } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof addFiles_args) + return this.equals((addFiles_args) that); + return false; + } - } - throw new IllegalStateException(); - } + public boolean equals(addFiles_args that) { + if (that == null) + return false; - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getLog_result) - return this.equals((getLog_result)that); - return false; - } + boolean this_present_links = true && this.isSetLinks(); + boolean that_present_links = true && that.isSetLinks(); + if (this_present_links || that_present_links) { + if (!(this_present_links && that_present_links)) + return false; + if (!this.links.equals(that.links)) + return false; + } - public boolean equals(getLog_result that) { - if (that == null) - return false; + 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; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - return true; - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - @Override - public int hashCode() { - return 0; - } + boolean present_links = true && (isSetLinks()); + list.add(present_links); + if (present_links) + list.add(links); - public int compareTo(getLog_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getLog_result typedOther = (getLog_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + return list.hashCode(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public int compareTo(addFiles_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + int lastComparison = 0; - 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("getLog_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(); - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetLinks()).compareTo(other.isSetLinks()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetLinks()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, other.links); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class getLog_resultStandardSchemeFactory implements SchemeFactory { - public getLog_resultStandardScheme getScheme() { - return new getLog_resultStandardScheme(); - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("addFiles_args("); + boolean first = true; - private static class getLog_resultStandardScheme extends StandardScheme<getLog_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getLog_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 _list80 = iprot.readListBegin(); - struct.success = new ArrayList<String>(_list80.size); - for (int _i81 = 0; _i81 < _list80.size; ++_i81) - { - String _elem82; // required - _elem82 = iprot.readString(); - struct.success.add(_elem82); - } - iprot.readListEnd(); - } - 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, getLog_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 (String _iter83 : struct.success) - { - oprot.writeString(_iter83); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + sb.append("pid:"); + sb.append(this.pid); + first = false; + if (!first) sb.append(", "); + sb.append("links:"); + if (this.links == null) { + sb.append("null"); + } else { + sb.append(this.links); + } + 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 static class getLog_resultTupleSchemeFactory implements SchemeFactory { - public getLog_resultTupleScheme getScheme() { - return new getLog_resultTupleScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class getLog_resultTupleScheme extends TupleScheme<getLog_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getLog_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (String _iter84 : struct.success) - { - oprot.writeString(_iter84); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getLog_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list85 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList<String>(_list85.size); - for (int _i86 = 0; _i86 < _list85.size; ++_i86) - { - String _elem87; // required - _elem87 = iprot.readString(); - struct.success.add(_elem87); - } - } - struct.setSuccessIsSet(true); - } - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 addFiles_argsStandardSchemeFactory implements SchemeFactory { + public addFiles_argsStandardScheme getScheme() { + return new addFiles_argsStandardScheme(); + } + } - public static class isTimeDownload_args implements org.apache.thrift.TBase<isTimeDownload_args, isTimeDownload_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeDownload_args"); + private static class addFiles_argsStandardScheme extends StandardScheme<addFiles_args> { + public void read(org.apache.thrift.protocol.TProtocol iprot, addFiles_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // LINKS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list282 = iprot.readListBegin(); + struct.links = new ArrayList<String>(_list282.size); + String _elem283; + for (int _i284 = 0; _i284 < _list282.size; ++_i284) { + _elem283 = iprot.readString(); + struct.links.add(_elem283); + } + iprot.readListEnd(); + } + struct.setLinksIsSet(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(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isTimeDownload_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isTimeDownload_argsTupleSchemeFactory()); - } + // 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, addFiles_args struct) throws org.apache.thrift.TException { + struct.validate(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeDownload_args.class, metaDataMap); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + if (struct.links != null) { + oprot.writeFieldBegin(LINKS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); + for (String _iter285 : struct.links) { + oprot.writeString(_iter285); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public isTimeDownload_args() { - } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isTimeDownload_args(isTimeDownload_args other) { - } + private static class addFiles_argsTupleSchemeFactory implements SchemeFactory { + public addFiles_argsTupleScheme getScheme() { + return new addFiles_argsTupleScheme(); + } + } - public isTimeDownload_args deepCopy() { - return new isTimeDownload_args(this); - } + private static class addFiles_argsTupleScheme extends TupleScheme<addFiles_args> { - @Override - public void clear() { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, addFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + if (struct.isSetLinks()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + if (struct.isSetLinks()) { + { + oprot.writeI32(struct.links.size()); + for (String _iter286 : struct.links) { + oprot.writeString(_iter286); + } + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, addFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + if (incoming.get(1)) { + { + org.apache.thrift.protocol.TList _list287 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.links = new ArrayList<String>(_list287.size); + String _elem288; + for (int _i289 = 0; _i289 < _list287.size; ++_i289) { + _elem288 = iprot.readString(); + struct.links.add(_elem288); + } + } + struct.setLinksIsSet(true); + } + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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) { - } - throw new IllegalStateException(); - } + public static class addFiles_result implements org.apache.thrift.TBase<addFiles_result, addFiles_result._Fields>, java.io.Serializable, Cloneable, Comparable<addFiles_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addFiles_result"); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isTimeDownload_args) - return this.equals((isTimeDownload_args)that); - return false; - } - public boolean equals(isTimeDownload_args that) { - if (that == null) - return false; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - return true; - } + static { + schemes.put(StandardScheme.class, new addFiles_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new addFiles_resultTupleSchemeFactory()); + } - @Override - public int hashCode() { - return 0; - } - public int compareTo(isTimeDownload_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - int lastComparison = 0; - isTimeDownload_args typedOther = (isTimeDownload_args)other; + @Override + public int describeContents() { + return 0; + } - return 0; - } + public addFiles_result(android.os.Parcel in) { + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static final android.os.Parcelable.Creator<addFiles_result> CREATOR = new android.os.Parcelable.Creator<addFiles_result>() { + @Override + public addFiles_result[] newArray(int size) { + return new addFiles_result[size]; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public addFiles_result createFromParcel(android.os.Parcel in) { + return new addFiles_result(in); + } + }; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("isTimeDownload_args("); - boolean first = true; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - sb.append(")"); - return sb.toString(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * 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; + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class isTimeDownload_argsStandardSchemeFactory implements SchemeFactory { - public isTimeDownload_argsStandardScheme getScheme() { - return new isTimeDownload_argsStandardScheme(); - } - } + private final short _thriftId; + private final String _fieldName; - private static class isTimeDownload_argsStandardScheme extends StandardScheme<isTimeDownload_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeDownload_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, isTimeDownload_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class isTimeDownload_argsTupleSchemeFactory implements SchemeFactory { - public isTimeDownload_argsTupleScheme getScheme() { - return new isTimeDownload_argsTupleScheme(); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class isTimeDownload_argsTupleScheme extends TupleScheme<isTimeDownload_args> { + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addFiles_result.class, metaDataMap); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public addFiles_result() { + } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public addFiles_result(addFiles_result other) { + } - public static class isTimeDownload_result implements org.apache.thrift.TBase<isTimeDownload_result, isTimeDownload_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeDownload_result"); + public addFiles_result deepCopy() { + return new addFiles_result(this); + } - 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); + @Override + public void clear() { + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isTimeDownload_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isTimeDownload_resultTupleSchemeFactory()); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public boolean 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 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 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 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; - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeDownload_result.class, metaDataMap); - } + /** 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(); + } - public isTimeDownload_result() { - } + switch (field) { + } + throw new IllegalStateException(); + } - public isTimeDownload_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof addFiles_result) + return this.equals((addFiles_result) that); + return false; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isTimeDownload_result(isTimeDownload_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + public boolean equals(addFiles_result that) { + if (that == null) + return false; - public isTimeDownload_result deepCopy() { - return new isTimeDownload_result(this); - } + return true; + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public boolean isSuccess() { - return this.success; - } + return list.hashCode(); + } - public isTimeDownload_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + @Override + public int compareTo(addFiles_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + int lastComparison = 0; - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + return 0; + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - break; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("addFiles_result("); + boolean first = true; - } - throw new IllegalStateException(); - } + sb.append(")"); + return sb.toString(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isTimeDownload_result) - return this.equals((isTimeDownload_result)that); - return false; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(isTimeDownload_result that) { - if (that == null) - return false; + 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); + } + } - 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; - } + private static class addFiles_resultStandardSchemeFactory implements SchemeFactory { + public addFiles_resultStandardScheme getScheme() { + return new addFiles_resultStandardScheme(); + } + } - return true; - } + private static class addFiles_resultStandardScheme extends StandardScheme<addFiles_result> { - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, addFiles_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public int compareTo(isTimeDownload_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - isTimeDownload_result typedOther = (isTimeDownload_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, addFiles_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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("isTimeDownload_result("); - boolean first = true; + private static class addFiles_resultTupleSchemeFactory implements SchemeFactory { + public addFiles_resultTupleScheme getScheme() { + return new addFiles_resultTupleScheme(); + } + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + private static class addFiles_resultTupleScheme extends TupleScheme<addFiles_result> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, addFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, addFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - 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.getMessage()); - } } - private static class isTimeDownload_resultStandardSchemeFactory implements SchemeFactory { - public isTimeDownload_resultStandardScheme getScheme() { - return new isTimeDownload_resultStandardScheme(); - } - } + public static class uploadContainer_args implements org.apache.thrift.TBase<uploadContainer_args, uploadContainer_args._Fields>, java.io.Serializable, Cloneable, Comparable<uploadContainer_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("uploadContainer_args"); - private static class isTimeDownload_resultStandardScheme extends StandardScheme<isTimeDownload_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeDownload_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; - 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, isTimeDownload_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final org.apache.thrift.protocol.TField FILENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("filename", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short) 2); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class isTimeDownload_resultTupleSchemeFactory implements SchemeFactory { - public isTimeDownload_resultTupleScheme getScheme() { - return new isTimeDownload_resultTupleScheme(); - } - } + static { + schemes.put(StandardScheme.class, new uploadContainer_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new uploadContainer_argsTupleSchemeFactory()); + } - private static class isTimeDownload_resultTupleScheme extends TupleScheme<isTimeDownload_result> { + public String filename; // required + public ByteBuffer data; // required - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(filename); + out.writeInt(data != null ? 1 : 0); + if (data != null) { + out.writeByteArray(data.array(), data.position() + data.arrayOffset(), data.limit() - data.position()); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isTimeDownload_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + @Override + public int describeContents() { + return 0; } - } - } - } + public uploadContainer_args(android.os.Parcel in) { + this.filename = in.readString(); + if (in.readInt() == 1) { + this.data = ByteBuffer.wrap(in.createByteArray()); + } + } - public static class isTimeReconnect_args implements org.apache.thrift.TBase<isTimeReconnect_args, isTimeReconnect_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeReconnect_args"); + public static final android.os.Parcelable.Creator<uploadContainer_args> CREATOR = new android.os.Parcelable.Creator<uploadContainer_args>() { + @Override + public uploadContainer_args[] newArray(int size) { + return new uploadContainer_args[size]; + } + @Override + public uploadContainer_args createFromParcel(android.os.Parcel in) { + return new uploadContainer_args(in); + } + }; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isTimeReconnect_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isTimeReconnect_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 { + FILENAME((short) 1, "filename"), + DATA((short) 2, "data"); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeReconnect_args.class, metaDataMap); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public isTimeReconnect_args() { - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FILENAME + return FILENAME; + case 2: // DATA + return DATA; + default: + return null; + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isTimeReconnect_args(isTimeReconnect_args other) { - } + /** + * 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; + } - public isTimeReconnect_args deepCopy() { - return new isTimeReconnect_args(this); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public void clear() { - } + private final short _thriftId; + private final String _fieldName; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public short getThriftFieldId() { + return _thriftId; + } - /** 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(); - } + public String getFieldName() { + return _fieldName; + } + } - switch (field) { - } - throw new IllegalStateException(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isTimeReconnect_args) - return this.equals((isTimeReconnect_args)that); - return false; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FILENAME, new org.apache.thrift.meta_data.FieldMetaData("filename", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, true))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(uploadContainer_args.class, metaDataMap); + } - public boolean equals(isTimeReconnect_args that) { - if (that == null) - return false; + public uploadContainer_args() { + } - return true; - } + public uploadContainer_args( + String filename, + ByteBuffer data) { + this(); + this.filename = filename; + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + } - @Override - public int hashCode() { - return 0; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public uploadContainer_args(uploadContainer_args other) { + if (other.isSetFilename()) { + this.filename = other.filename; + } + if (other.isSetData()) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); + } + } - public int compareTo(isTimeReconnect_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public uploadContainer_args deepCopy() { + return new uploadContainer_args(this); + } - int lastComparison = 0; - isTimeReconnect_args typedOther = (isTimeReconnect_args)other; + @Override + public void clear() { + this.filename = null; + this.data = null; + } - return 0; - } + public String getFilename() { + return this.filename; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public uploadContainer_args setFilename(String filename) { + this.filename = filename; + return this; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void unsetFilename() { + this.filename = null; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** Returns true if field filename is set (has been assigned a value) and false otherwise */ + public boolean isSetFilename() { + return this.filename != null; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("isTimeReconnect_args("); - boolean first = true; + public void setFilenameIsSet(boolean value) { + if (!value) { + this.filename = null; + } + } - sb.append(")"); - return sb.toString(); - } + public byte[] getData() { + setData(org.apache.thrift.TBaseHelper.rightSize(data)); + return data == null ? null : data.array(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public ByteBuffer bufferForData() { + return org.apache.thrift.TBaseHelper.copyBinary(data); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public uploadContainer_args setData(byte[] data) { + this.data = data == null ? (ByteBuffer) null : ByteBuffer.wrap(Arrays.copyOf(data, data.length)); + return this; + } - 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.getMessage()); - } - } + public uploadContainer_args setData(ByteBuffer data) { + this.data = org.apache.thrift.TBaseHelper.copyBinary(data); + return this; + } - private static class isTimeReconnect_argsStandardSchemeFactory implements SchemeFactory { - public isTimeReconnect_argsStandardScheme getScheme() { - return new isTimeReconnect_argsStandardScheme(); - } - } + public void unsetData() { + this.data = null; + } - private static class isTimeReconnect_argsStandardScheme extends StandardScheme<isTimeReconnect_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeReconnect_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, isTimeReconnect_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } - } + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } - private static class isTimeReconnect_argsTupleSchemeFactory implements SchemeFactory { - public isTimeReconnect_argsTupleScheme getScheme() { - return new isTimeReconnect_argsTupleScheme(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FILENAME: + if (value == null) { + unsetFilename(); + } else { + setFilename((String) value); + } + break; - private static class isTimeReconnect_argsTupleScheme extends TupleScheme<isTimeReconnect_args> { + case DATA: + if (value == null) { + unsetData(); + } else { + setData((ByteBuffer) value); + } + break; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FILENAME: + return getFilename(); - } + case DATA: + return getData(); - public static class isTimeReconnect_result implements org.apache.thrift.TBase<isTimeReconnect_result, isTimeReconnect_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isTimeReconnect_result"); + } + throw new IllegalStateException(); + } - 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); + /** 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isTimeReconnect_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isTimeReconnect_resultTupleSchemeFactory()); - } + switch (field) { + case FILENAME: + return isSetFilename(); + case DATA: + return isSetData(); + } + throw new IllegalStateException(); + } - public boolean 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 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 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 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; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof uploadContainer_args) + return this.equals((uploadContainer_args) that); + return false; + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isTimeReconnect_result.class, metaDataMap); - } + public boolean equals(uploadContainer_args that) { + if (that == null) + return false; - public isTimeReconnect_result() { - } + boolean this_present_filename = true && this.isSetFilename(); + boolean that_present_filename = true && that.isSetFilename(); + if (this_present_filename || that_present_filename) { + if (!(this_present_filename && that_present_filename)) + return false; + if (!this.filename.equals(that.filename)) + return false; + } - public isTimeReconnect_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + return false; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isTimeReconnect_result(isTimeReconnect_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + return true; + } - public isTimeReconnect_result deepCopy() { - return new isTimeReconnect_result(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + boolean present_filename = true && (isSetFilename()); + list.add(present_filename); + if (present_filename) + list.add(filename); - public boolean isSuccess() { - return this.success; - } + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); - public isTimeReconnect_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + return list.hashCode(); + } - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + @Override + public int compareTo(uploadContainer_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + int lastComparison = 0; - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + lastComparison = Boolean.valueOf(isSetFilename()).compareTo(other.isSetFilename()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFilename()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filename, other.filename); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - break; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - } - throw new IllegalStateException(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("uploadContainer_args("); + boolean first = true; - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + sb.append("filename:"); + if (this.filename == null) { + sb.append("null"); + } else { + sb.append(this.filename); + } + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + org.apache.thrift.TBaseHelper.toString(this.data, sb); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isTimeReconnect_result) - return this.equals((isTimeReconnect_result)that); - return false; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public boolean equals(isTimeReconnect_result that) { - if (that == null) - return false; + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - 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; - } + 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); + } + } - return true; - } + private static class uploadContainer_argsStandardSchemeFactory implements SchemeFactory { + public uploadContainer_argsStandardScheme getScheme() { + return new uploadContainer_argsStandardScheme(); + } + } - @Override - public int hashCode() { - return 0; - } + private static class uploadContainer_argsStandardScheme extends StandardScheme<uploadContainer_args> { - public int compareTo(isTimeReconnect_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - isTimeReconnect_result typedOther = (isTimeReconnect_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, uploadContainer_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: // FILENAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.filename = iprot.readString(); + struct.setFilenameIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(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(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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, uploadContainer_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.filename != null) { + oprot.writeFieldBegin(FILENAME_FIELD_DESC); + oprot.writeString(struct.filename); + oprot.writeFieldEnd(); + } + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + oprot.writeBinary(struct.data); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("isTimeReconnect_result("); - boolean first = true; + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + private static class uploadContainer_argsTupleSchemeFactory implements SchemeFactory { + public uploadContainer_argsTupleScheme getScheme() { + return new uploadContainer_argsTupleScheme(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class uploadContainer_argsTupleScheme extends TupleScheme<uploadContainer_args> { - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, uploadContainer_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFilename()) { + optionals.set(0); + } + if (struct.isSetData()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetFilename()) { + oprot.writeString(struct.filename); + } + if (struct.isSetData()) { + oprot.writeBinary(struct.data); + } + } - 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.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, uploadContainer_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.filename = iprot.readString(); + struct.setFilenameIsSet(true); + } + if (incoming.get(1)) { + struct.data = iprot.readBinary(); + struct.setDataIsSet(true); + } + } + } - private static class isTimeReconnect_resultStandardSchemeFactory implements SchemeFactory { - public isTimeReconnect_resultStandardScheme getScheme() { - return new isTimeReconnect_resultStandardScheme(); - } } - private static class isTimeReconnect_resultStandardScheme extends StandardScheme<isTimeReconnect_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isTimeReconnect_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; - 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, isTimeReconnect_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } + public static class uploadContainer_result implements org.apache.thrift.TBase<uploadContainer_result, uploadContainer_result._Fields>, java.io.Serializable, Cloneable, Comparable<uploadContainer_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("uploadContainer_result"); - private static class isTimeReconnect_resultTupleSchemeFactory implements SchemeFactory { - public isTimeReconnect_resultTupleScheme getScheme() { - return new isTimeReconnect_resultTupleScheme(); - } - } - private static class isTimeReconnect_resultTupleScheme extends TupleScheme<isTimeReconnect_result> { + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + static { + schemes.put(StandardScheme.class, new uploadContainer_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new uploadContainer_resultTupleSchemeFactory()); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); + + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isTimeReconnect_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + @Override + public int describeContents() { + return 0; } - } - } - } + public uploadContainer_result(android.os.Parcel in) { + } - public static class toggleReconnect_args implements org.apache.thrift.TBase<toggleReconnect_args, toggleReconnect_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("toggleReconnect_args"); + public static final android.os.Parcelable.Creator<uploadContainer_result> CREATOR = new android.os.Parcelable.Creator<uploadContainer_result>() { + @Override + public uploadContainer_result[] newArray(int size) { + return new uploadContainer_result[size]; + } + @Override + public uploadContainer_result createFromParcel(android.os.Parcel in) { + return new uploadContainer_result(in); + } + }; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new toggleReconnect_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new toggleReconnect_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 Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(toggleReconnect_args.class, metaDataMap); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public toggleReconnect_args() { - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public toggleReconnect_args(toggleReconnect_args other) { - } + /** + * 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; + } - public toggleReconnect_args deepCopy() { - return new toggleReconnect_args(this); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public void clear() { - } + private final short _thriftId; + private final String _fieldName; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public short getThriftFieldId() { + return _thriftId; + } - /** 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(); - } + public String getFieldName() { + return _fieldName; + } + } - switch (field) { - } - throw new IllegalStateException(); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof toggleReconnect_args) - return this.equals((toggleReconnect_args)that); - return false; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(uploadContainer_result.class, metaDataMap); + } - public boolean equals(toggleReconnect_args that) { - if (that == null) - return false; + public uploadContainer_result() { + } - return true; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public uploadContainer_result(uploadContainer_result other) { + } - @Override - public int hashCode() { - return 0; - } + public uploadContainer_result deepCopy() { + return new uploadContainer_result(this); + } - public int compareTo(toggleReconnect_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public void clear() { + } - int lastComparison = 0; - toggleReconnect_args typedOther = (toggleReconnect_args)other; + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** 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(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + switch (field) { + } + throw new IllegalStateException(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof uploadContainer_result) + return this.equals((uploadContainer_result) that); + return false; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("toggleReconnect_args("); - boolean first = true; + public boolean equals(uploadContainer_result that) { + if (that == null) + return false; - sb.append(")"); - return sb.toString(); - } + return true; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return list.hashCode(); + } - 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.getMessage()); - } - } + @Override + public int compareTo(uploadContainer_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class toggleReconnect_argsStandardSchemeFactory implements SchemeFactory { - public toggleReconnect_argsStandardScheme getScheme() { - return new toggleReconnect_argsStandardScheme(); - } - } + int lastComparison = 0; - private static class toggleReconnect_argsStandardScheme extends StandardScheme<toggleReconnect_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, toggleReconnect_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, toggleReconnect_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return 0; + } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class toggleReconnect_argsTupleSchemeFactory implements SchemeFactory { - public toggleReconnect_argsTupleScheme getScheme() { - return new toggleReconnect_argsTupleScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class toggleReconnect_argsTupleScheme extends TupleScheme<toggleReconnect_args> { + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("uploadContainer_result("); + boolean first = true; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + sb.append(")"); + return sb.toString(); + } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public static class toggleReconnect_result implements org.apache.thrift.TBase<toggleReconnect_result, toggleReconnect_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("toggleReconnect_result"); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - 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 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 final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new toggleReconnect_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new toggleReconnect_resultTupleSchemeFactory()); - } + private static class uploadContainer_resultStandardSchemeFactory implements SchemeFactory { + public uploadContainer_resultStandardScheme getScheme() { + return new uploadContainer_resultStandardScheme(); + } + } - public boolean 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 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 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 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; - } - } + private static class uploadContainer_resultStandardScheme extends StandardScheme<uploadContainer_result> { - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(toggleReconnect_result.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, uploadContainer_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public toggleReconnect_result() { - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public toggleReconnect_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, uploadContainer_result struct) throws org.apache.thrift.TException { + struct.validate(); - /** - * Performs a deep copy on <i>other</i>. - */ - public toggleReconnect_result(toggleReconnect_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public toggleReconnect_result deepCopy() { - return new toggleReconnect_result(this); - } + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + private static class uploadContainer_resultTupleSchemeFactory implements SchemeFactory { + public uploadContainer_resultTupleScheme getScheme() { + return new uploadContainer_resultTupleScheme(); + } + } - public boolean isSuccess() { - return this.success; - } + private static class uploadContainer_resultTupleScheme extends TupleScheme<uploadContainer_result> { - public toggleReconnect_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, uploadContainer_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, uploadContainer_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + public static class deleteFiles_args implements org.apache.thrift.TBase<deleteFiles_args, deleteFiles_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteFiles_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFiles_args"); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); - } - break; + private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short) 1); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + static { + schemes.put(StandardScheme.class, new deleteFiles_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deleteFiles_argsTupleSchemeFactory()); + } - } - throw new IllegalStateException(); - } + public List<Integer> fids; // required - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(fids); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof toggleReconnect_result) - return this.equals((toggleReconnect_result)that); - return false; - } + @Override + public int describeContents() { + return 0; + } - public boolean equals(toggleReconnect_result that) { - if (that == null) - return false; + public deleteFiles_args(android.os.Parcel in) { + this.fids = new ArrayList<Integer>(); + in.readList(this.fids, deleteFiles_args.class.getClassLoader()); + } - 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; - } + public static final android.os.Parcelable.Creator<deleteFiles_args> CREATOR = new android.os.Parcelable.Creator<deleteFiles_args>() { + @Override + public deleteFiles_args[] newArray(int size) { + return new deleteFiles_args[size]; + } - return true; - } + @Override + public deleteFiles_args createFromParcel(android.os.Parcel in) { + return new deleteFiles_args(in); + } + }; - @Override - public int hashCode() { - return 0; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FIDS((short) 1, "fids"); - public int compareTo(toggleReconnect_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - toggleReconnect_result typedOther = (toggleReconnect_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FIDS + return FIDS; + default: + return null; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** + * 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; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("toggleReconnect_result("); - boolean first = true; + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + private final short _thriftId; + private final String _fieldName; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public short getThriftFieldId() { + return _thriftId; + } - 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.getMessage()); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class toggleReconnect_resultStandardSchemeFactory implements SchemeFactory { - public toggleReconnect_resultStandardScheme getScheme() { - return new toggleReconnect_resultStandardScheme(); - } - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class toggleReconnect_resultStandardScheme extends StandardScheme<toggleReconnect_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, toggleReconnect_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; - 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, toggleReconnect_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32, "FileID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFiles_args.class, metaDataMap); + } - } + public deleteFiles_args() { + } - private static class toggleReconnect_resultTupleSchemeFactory implements SchemeFactory { - public toggleReconnect_resultTupleScheme getScheme() { - return new toggleReconnect_resultTupleScheme(); - } - } + public deleteFiles_args( + List<Integer> fids) { + this(); + this.fids = fids; + } - private static class toggleReconnect_resultTupleScheme extends TupleScheme<toggleReconnect_result> { + /** + * Performs a deep copy on <i>other</i>. + */ + public deleteFiles_args(deleteFiles_args other) { + if (other.isSetFids()) { + List<Integer> __this__fids = new ArrayList<Integer>(other.fids.size()); + for (Integer other_element : other.fids) { + __this__fids.add(other_element); + } + this.fids = __this__fids; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + public deleteFiles_args deepCopy() { + return new deleteFiles_args(this); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); + + @Override + public void clear() { + this.fids = null; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, toggleReconnect_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + public int getFidsSize() { + return (this.fids == null) ? 0 : this.fids.size(); } - } - } - } + public java.util.Iterator<Integer> getFidsIterator() { + return (this.fids == null) ? null : this.fids.iterator(); + } - public static class generatePackages_args implements org.apache.thrift.TBase<generatePackages_args, generatePackages_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generatePackages_args"); + public void addToFids(int elem) { + if (this.fids == null) { + this.fids = new ArrayList<Integer>(); + } + this.fids.add(elem); + } - private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short)1); + public List<Integer> getFids() { + return this.fids; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new generatePackages_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new generatePackages_argsTupleSchemeFactory()); - } + public deleteFiles_args setFids(List<Integer> fids) { + this.fids = fids; + return this; + } - public List<String> links; // 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 { - LINKS((short)1, "links"); - - 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: // LINKS - return LINKS; - 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; - } - } + public void unsetFids() { + this.fids = null; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generatePackages_args.class, metaDataMap); - } + /** Returns true if field fids is set (has been assigned a value) and false otherwise */ + public boolean isSetFids() { + return this.fids != null; + } - public generatePackages_args() { - } + public void setFidsIsSet(boolean value) { + if (!value) { + this.fids = null; + } + } - public generatePackages_args( - List<String> links) - { - this(); - this.links = links; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FIDS: + if (value == null) { + unsetFids(); + } else { + setFids((List<Integer>) value); + } + break; - /** - * Performs a deep copy on <i>other</i>. - */ - public generatePackages_args(generatePackages_args other) { - if (other.isSetLinks()) { - this.links = other.links; - } - } + } + } - public generatePackages_args deepCopy() { - return new generatePackages_args(this); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FIDS: + return getFids(); - @Override - public void clear() { - this.links = null; - } + } + throw new IllegalStateException(); + } - public int getLinksSize() { - return (this.links == null) ? 0 : this.links.size(); - } + /** 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(); + } - public java.util.Iterator<String> getLinksIterator() { - return (this.links == null) ? null : this.links.iterator(); - } + switch (field) { + case FIDS: + return isSetFids(); + } + throw new IllegalStateException(); + } - public void addToLinks(String elem) { - if (this.links == null) { - this.links = new ArrayList<String>(); - } - this.links.add(elem); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteFiles_args) + return this.equals((deleteFiles_args) that); + return false; + } - public List<String> getLinks() { - return this.links; - } + public boolean equals(deleteFiles_args that) { + if (that == null) + return false; - public generatePackages_args setLinks(List<String> links) { - this.links = links; - return this; - } + boolean this_present_fids = true && this.isSetFids(); + boolean that_present_fids = true && that.isSetFids(); + if (this_present_fids || that_present_fids) { + if (!(this_present_fids && that_present_fids)) + return false; + if (!this.fids.equals(that.fids)) + return false; + } - public void unsetLinks() { - this.links = null; - } + return true; + } - /** Returns true if field links is set (has been assigned a value) and false otherwise */ - public boolean isSetLinks() { - return this.links != null; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void setLinksIsSet(boolean value) { - if (!value) { - this.links = null; - } - } + boolean present_fids = true && (isSetFids()); + list.add(present_fids); + if (present_fids) + list.add(fids); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case LINKS: - if (value == null) { - unsetLinks(); - } else { - setLinks((List<String>)value); + return list.hashCode(); } - break; - } - } + @Override + public int compareTo(deleteFiles_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case LINKS: - return getLinks(); + int lastComparison = 0; - } - throw new IllegalStateException(); - } + lastComparison = Boolean.valueOf(isSetFids()).compareTo(other.isSetFids()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFids()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, other.fids); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - /** 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 LINKS: - return isSetLinks(); - } - throw new IllegalStateException(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof generatePackages_args) - return this.equals((generatePackages_args)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public boolean equals(generatePackages_args that) { - if (that == null) - return false; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - boolean this_present_links = true && this.isSetLinks(); - boolean that_present_links = true && that.isSetLinks(); - if (this_present_links || that_present_links) { - if (!(this_present_links && that_present_links)) - return false; - if (!this.links.equals(that.links)) - return false; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deleteFiles_args("); + boolean first = true; - return true; - } + sb.append("fids:"); + if (this.fids == null) { + sb.append("null"); + } else { + sb.append(this.fids); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public int hashCode() { - return 0; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public int compareTo(generatePackages_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - generatePackages_args typedOther = (generatePackages_args)other; - - lastComparison = Boolean.valueOf(isSetLinks()).compareTo(typedOther.isSetLinks()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinks()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, typedOther.links); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class deleteFiles_argsStandardSchemeFactory implements SchemeFactory { + public deleteFiles_argsStandardScheme getScheme() { + return new deleteFiles_argsStandardScheme(); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + private static class deleteFiles_argsStandardScheme extends StandardScheme<deleteFiles_args> { - @Override - public String toString() { - StringBuilder sb = new StringBuilder("generatePackages_args("); - boolean first = true; - - sb.append("links:"); - if (this.links == null) { - sb.append("null"); - } else { - sb.append(this.links); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFiles_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: // FIDS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list290 = iprot.readListBegin(); + struct.fids = new ArrayList<Integer>(_list290.size); + int _elem291; + for (int _i292 = 0; _i292 < _list290.size; ++_i292) { + _elem291 = iprot.readI32(); + struct.fids.add(_elem291); + } + iprot.readListEnd(); + } + struct.setFidsIsSet(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(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, deleteFiles_args struct) throws org.apache.thrift.TException { + struct.validate(); - 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.getMessage()); - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.fids != null) { + oprot.writeFieldBegin(FIDS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); + for (int _iter293 : struct.fids) { + oprot.writeI32(_iter293); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class generatePackages_argsStandardSchemeFactory implements SchemeFactory { - public generatePackages_argsStandardScheme getScheme() { - return new generatePackages_argsStandardScheme(); - } - } + } - private static class generatePackages_argsStandardScheme extends StandardScheme<generatePackages_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, generatePackages_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: // LINKS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list88 = iprot.readListBegin(); - struct.links = new ArrayList<String>(_list88.size); - for (int _i89 = 0; _i89 < _list88.size; ++_i89) - { - String _elem90; // required - _elem90 = iprot.readString(); - struct.links.add(_elem90); - } - iprot.readListEnd(); - } - struct.setLinksIsSet(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, generatePackages_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.links != null) { - oprot.writeFieldBegin(LINKS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); - for (String _iter91 : struct.links) - { - oprot.writeString(_iter91); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static class deleteFiles_argsTupleSchemeFactory implements SchemeFactory { + public deleteFiles_argsTupleScheme getScheme() { + return new deleteFiles_argsTupleScheme(); + } + } - } + private static class deleteFiles_argsTupleScheme extends TupleScheme<deleteFiles_args> { - private static class generatePackages_argsTupleSchemeFactory implements SchemeFactory { - public generatePackages_argsTupleScheme getScheme() { - return new generatePackages_argsTupleScheme(); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deleteFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFids()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetFids()) { + { + oprot.writeI32(struct.fids.size()); + for (int _iter294 : struct.fids) { + oprot.writeI32(_iter294); + } + } + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deleteFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list295 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.fids = new ArrayList<Integer>(_list295.size); + int _elem296; + for (int _i297 = 0; _i297 < _list295.size; ++_i297) { + _elem296 = iprot.readI32(); + struct.fids.add(_elem296); + } + } + struct.setFidsIsSet(true); + } + } + } - private static class generatePackages_argsTupleScheme extends TupleScheme<generatePackages_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, generatePackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetLinks()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetLinks()) { - { - oprot.writeI32(struct.links.size()); - for (String _iter92 : struct.links) - { - oprot.writeString(_iter92); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, generatePackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list93 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.links = new ArrayList<String>(_list93.size); - for (int _i94 = 0; _i94 < _list93.size; ++_i94) - { - String _elem95; // required - _elem95 = iprot.readString(); - struct.links.add(_elem95); - } - } - struct.setLinksIsSet(true); - } - } } - } + public static class deleteFiles_result implements org.apache.thrift.TBase<deleteFiles_result, deleteFiles_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteFiles_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFiles_result"); - public static class generatePackages_result implements org.apache.thrift.TBase<generatePackages_result, generatePackages_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generatePackages_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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new generatePackages_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new generatePackages_resultTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new deleteFiles_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deleteFiles_resultTupleSchemeFactory()); + } - public Map<String,List<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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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.LIST , "LinkList")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generatePackages_result.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public generatePackages_result() { - } + @Override + public int describeContents() { + return 0; + } - public generatePackages_result( - Map<String,List<String>> success) - { - this(); - this.success = success; - } + public deleteFiles_result(android.os.Parcel in) { + } - /** - * Performs a deep copy on <i>other</i>. - */ - public generatePackages_result(generatePackages_result other) { - if (other.isSetSuccess()) { - Map<String,List<String>> __this__success = new HashMap<String,List<String>>(); - for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + public static final android.os.Parcelable.Creator<deleteFiles_result> CREATOR = new android.os.Parcelable.Creator<deleteFiles_result>() { + @Override + public deleteFiles_result[] newArray(int size) { + return new deleteFiles_result[size]; + } - String other_element_key = other_element.getKey(); - List<String> other_element_value = other_element.getValue(); + @Override + public deleteFiles_result createFromParcel(android.os.Parcel in) { + return new deleteFiles_result(in); + } + }; - String __this__success_copy_key = other_element_key; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - List<String> __this__success_copy_value = other_element_value; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - __this__success.put(__this__success_copy_key, __this__success_copy_value); - } - this.success = __this__success; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public generatePackages_result deepCopy() { - return new generatePackages_result(this); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - @Override - public void clear() { - this.success = 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; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void putToSuccess(String key, List<String> val) { - if (this.success == null) { - this.success = new HashMap<String,List<String>>(); - } - this.success.put(key, val); - } + private final short _thriftId; + private final String _fieldName; - public Map<String,List<String>> getSuccess() { - return this.success; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public generatePackages_result setSuccess(Map<String,List<String>> success) { - this.success = success; - return this; - } + public short getThriftFieldId() { + return _thriftId; + } - public void unsetSuccess() { - this.success = null; - } + public String getFieldName() { + return _fieldName; + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFiles_result.class, metaDataMap); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,List<String>>)value); + public deleteFiles_result() { } - break; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public deleteFiles_result(deleteFiles_result other) { + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public deleteFiles_result deepCopy() { + return new deleteFiles_result(this); + } - } - throw new IllegalStateException(); - } + @Override + public void clear() { + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof generatePackages_result) - return this.equals((generatePackages_result)that); - return false; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public boolean equals(generatePackages_result that) { - if (that == null) - return false; + /** 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(); + } - 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; - } + switch (field) { + } + throw new IllegalStateException(); + } - return true; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteFiles_result) + return this.equals((deleteFiles_result) that); + return false; + } - @Override - public int hashCode() { - return 0; - } + public boolean equals(deleteFiles_result that) { + if (that == null) + return false; - public int compareTo(generatePackages_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - generatePackages_result typedOther = (generatePackages_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + return true; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return list.hashCode(); + } - 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("generatePackages_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(); - } + @Override + public int compareTo(deleteFiles_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + int lastComparison = 0; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return 0; + } - 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.getMessage()); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class generatePackages_resultStandardSchemeFactory implements SchemeFactory { - public generatePackages_resultStandardScheme getScheme() { - return new generatePackages_resultStandardScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class generatePackages_resultStandardScheme extends StandardScheme<generatePackages_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, generatePackages_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 _map96 = iprot.readMapBegin(); - struct.success = new HashMap<String,List<String>>(2*_map96.size); - for (int _i97 = 0; _i97 < _map96.size; ++_i97) - { - String _key98; // required - List<String> _val99; // required - _key98 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list100 = iprot.readListBegin(); - _val99 = new ArrayList<String>(_list100.size); - for (int _i101 = 0; _i101 < _list100.size; ++_i101) - { - String _elem102; // required - _elem102 = iprot.readString(); - _val99.add(_elem102); - } - iprot.readListEnd(); - } - struct.success.put(_key98, _val99); - } - iprot.readMapEnd(); - } - 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, generatePackages_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.LIST, struct.success.size())); - for (Map.Entry<String, List<String>> _iter103 : struct.success.entrySet()) - { - oprot.writeString(_iter103.getKey()); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter103.getValue().size())); - for (String _iter104 : _iter103.getValue()) - { - oprot.writeString(_iter104); - } - oprot.writeListEnd(); - } - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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("deleteFiles_result("); + boolean first = true; - private static class generatePackages_resultTupleSchemeFactory implements SchemeFactory { - public generatePackages_resultTupleScheme getScheme() { - return new generatePackages_resultTupleScheme(); - } - } + sb.append(")"); + return sb.toString(); + } - private static class generatePackages_resultTupleScheme extends TupleScheme<generatePackages_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, generatePackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, List<String>> _iter105 : struct.success.entrySet()) - { - oprot.writeString(_iter105.getKey()); - { - oprot.writeI32(_iter105.getValue().size()); - for (String _iter106 : _iter105.getValue()) - { - oprot.writeString(_iter106); - } - } - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, generatePackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map107 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); - struct.success = new HashMap<String,List<String>>(2*_map107.size); - for (int _i108 = 0; _i108 < _map107.size; ++_i108) - { - String _key109; // required - List<String> _val110; // required - _key109 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list111 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val110 = new ArrayList<String>(_list111.size); - for (int _i112 = 0; _i112 < _list111.size; ++_i112) - { - String _elem113; // required - _elem113 = iprot.readString(); - _val110.add(_elem113); - } - } - struct.success.put(_key109, _val110); - } - } - struct.setSuccessIsSet(true); - } - } - } + 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); + } + } - public static class checkURLs_args implements org.apache.thrift.TBase<checkURLs_args, checkURLs_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkURLs_args"); + 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 final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short)1); + private static class deleteFiles_resultStandardSchemeFactory implements SchemeFactory { + public deleteFiles_resultStandardScheme getScheme() { + return new deleteFiles_resultStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkURLs_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkURLs_argsTupleSchemeFactory()); - } + private static class deleteFiles_resultStandardScheme extends StandardScheme<deleteFiles_result> { - public List<String> urls; // 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 { - URLS((short)1, "urls"); - - 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: // URLS - return URLS; - 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; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFiles_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkURLs_args.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public checkURLs_args() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, deleteFiles_result struct) throws org.apache.thrift.TException { + struct.validate(); - public checkURLs_args( - List<String> urls) - { - this(); - this.urls = urls; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public checkURLs_args(checkURLs_args other) { - if (other.isSetUrls()) { - this.urls = other.urls; - } - } + } - public checkURLs_args deepCopy() { - return new checkURLs_args(this); - } + private static class deleteFiles_resultTupleSchemeFactory implements SchemeFactory { + public deleteFiles_resultTupleScheme getScheme() { + return new deleteFiles_resultTupleScheme(); + } + } - @Override - public void clear() { - this.urls = null; - } + private static class deleteFiles_resultTupleScheme extends TupleScheme<deleteFiles_result> { - public int getUrlsSize() { - return (this.urls == null) ? 0 : this.urls.size(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deleteFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public java.util.Iterator<String> getUrlsIterator() { - return (this.urls == null) ? null : this.urls.iterator(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deleteFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public void addToUrls(String elem) { - if (this.urls == null) { - this.urls = new ArrayList<String>(); - } - this.urls.add(elem); } - public List<String> getUrls() { - return this.urls; - } + public static class deletePackages_args implements org.apache.thrift.TBase<deletePackages_args, deletePackages_args._Fields>, java.io.Serializable, Cloneable, Comparable<deletePackages_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deletePackages_args"); - public checkURLs_args setUrls(List<String> urls) { - this.urls = urls; - return this; - } + private static final org.apache.thrift.protocol.TField PIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("pids", org.apache.thrift.protocol.TType.LIST, (short) 1); - public void unsetUrls() { - this.urls = null; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** Returns true if field urls is set (has been assigned a value) and false otherwise */ - public boolean isSetUrls() { - return this.urls != null; - } + static { + schemes.put(StandardScheme.class, new deletePackages_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deletePackages_argsTupleSchemeFactory()); + } - public void setUrlsIsSet(boolean value) { - if (!value) { - this.urls = null; - } - } + public List<Integer> pids; // required - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case URLS: - if (value == null) { - unsetUrls(); - } else { - setUrls((List<String>)value); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(pids); } - break; - } - } + @Override + public int describeContents() { + return 0; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case URLS: - return getUrls(); + public deletePackages_args(android.os.Parcel in) { + this.pids = new ArrayList<Integer>(); + in.readList(this.pids, deletePackages_args.class.getClassLoader()); + } - } - throw new IllegalStateException(); - } + public static final android.os.Parcelable.Creator<deletePackages_args> CREATOR = new android.os.Parcelable.Creator<deletePackages_args>() { + @Override + public deletePackages_args[] newArray(int size) { + return new deletePackages_args[size]; + } - /** 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 URLS: - return isSetUrls(); - } - throw new IllegalStateException(); - } + @Override + public deletePackages_args createFromParcel(android.os.Parcel in) { + return new deletePackages_args(in); + } + }; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkURLs_args) - return this.equals((checkURLs_args)that); - return false; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PIDS((short) 1, "pids"); - public boolean equals(checkURLs_args that) { - if (that == null) - return false; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - boolean this_present_urls = true && this.isSetUrls(); - boolean that_present_urls = true && that.isSetUrls(); - if (this_present_urls || that_present_urls) { - if (!(this_present_urls && that_present_urls)) - return false; - if (!this.urls.equals(that.urls)) - return false; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - return true; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PIDS + return PIDS; + default: + return null; + } + } - @Override - public int hashCode() { - return 0; - } + /** + * 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; + } - public int compareTo(checkURLs_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkURLs_args typedOther = (checkURLs_args)other; - - lastComparison = Boolean.valueOf(isSetUrls()).compareTo(typedOther.isSetUrls()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUrls()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, typedOther.urls); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private final short _thriftId; + private final String _fieldName; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("checkURLs_args("); - boolean first = true; - - sb.append("urls:"); - if (this.urls == null) { - sb.append("null"); - } else { - sb.append(this.urls); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public String getFieldName() { + return _fieldName; + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PIDS, new org.apache.thrift.meta_data.FieldMetaData("pids", 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.I32, "PackageID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deletePackages_args.class, metaDataMap); + } - 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.getMessage()); - } - } + public deletePackages_args() { + } - private static class checkURLs_argsStandardSchemeFactory implements SchemeFactory { - public checkURLs_argsStandardScheme getScheme() { - return new checkURLs_argsStandardScheme(); - } - } + public deletePackages_args( + List<Integer> pids) { + this(); + this.pids = pids; + } - private static class checkURLs_argsStandardScheme extends StandardScheme<checkURLs_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkURLs_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: // URLS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list114 = iprot.readListBegin(); - struct.urls = new ArrayList<String>(_list114.size); - for (int _i115 = 0; _i115 < _list114.size; ++_i115) - { - String _elem116; // required - _elem116 = iprot.readString(); - struct.urls.add(_elem116); - } - iprot.readListEnd(); - } - struct.setUrlsIsSet(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, checkURLs_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.urls != null) { - oprot.writeFieldBegin(URLS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); - for (String _iter117 : struct.urls) - { - oprot.writeString(_iter117); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public deletePackages_args(deletePackages_args other) { + if (other.isSetPids()) { + List<Integer> __this__pids = new ArrayList<Integer>(other.pids.size()); + for (Integer other_element : other.pids) { + __this__pids.add(other_element); + } + this.pids = __this__pids; + } + } - } + public deletePackages_args deepCopy() { + return new deletePackages_args(this); + } - private static class checkURLs_argsTupleSchemeFactory implements SchemeFactory { - public checkURLs_argsTupleScheme getScheme() { - return new checkURLs_argsTupleScheme(); - } - } + @Override + public void clear() { + this.pids = null; + } - private static class checkURLs_argsTupleScheme extends TupleScheme<checkURLs_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkURLs_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUrls()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetUrls()) { - { - oprot.writeI32(struct.urls.size()); - for (String _iter118 : struct.urls) - { - oprot.writeString(_iter118); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkURLs_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list119 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.urls = new ArrayList<String>(_list119.size); - for (int _i120 = 0; _i120 < _list119.size; ++_i120) - { - String _elem121; // required - _elem121 = iprot.readString(); - struct.urls.add(_elem121); - } - } - struct.setUrlsIsSet(true); - } - } - } + public int getPidsSize() { + return (this.pids == null) ? 0 : this.pids.size(); + } - } + public java.util.Iterator<Integer> getPidsIterator() { + return (this.pids == null) ? null : this.pids.iterator(); + } - public static class checkURLs_result implements org.apache.thrift.TBase<checkURLs_result, checkURLs_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkURLs_result"); + public void addToPids(int elem) { + if (this.pids == null) { + this.pids = new ArrayList<Integer>(); + } + this.pids.add(elem); + } - 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); + public List<Integer> getPids() { + return this.pids; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkURLs_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkURLs_resultTupleSchemeFactory()); - } + public deletePackages_args setPids(List<Integer> pids) { + this.pids = pids; + return this; + } - public Map<String,List<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 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 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 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; - } - } + public void unsetPids() { + this.pids = null; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkURLs_result.class, metaDataMap); - } + /** Returns true if field pids is set (has been assigned a value) and false otherwise */ + public boolean isSetPids() { + return this.pids != null; + } - public checkURLs_result() { - } + public void setPidsIsSet(boolean value) { + if (!value) { + this.pids = null; + } + } - public checkURLs_result( - Map<String,List<String>> success) - { - this(); - this.success = success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PIDS: + if (value == null) { + unsetPids(); + } else { + setPids((List<Integer>) value); + } + break; - /** - * Performs a deep copy on <i>other</i>. - */ - public checkURLs_result(checkURLs_result other) { - if (other.isSetSuccess()) { - Map<String,List<String>> __this__success = new HashMap<String,List<String>>(); - for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + } + } - String other_element_key = other_element.getKey(); - List<String> other_element_value = other_element.getValue(); + public Object getFieldValue(_Fields field) { + switch (field) { + case PIDS: + return getPids(); - String __this__success_copy_key = other_element_key; + } + throw new IllegalStateException(); + } - List<String> __this__success_copy_value = other_element_value; + /** 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(); + } - __this__success.put(__this__success_copy_key, __this__success_copy_value); + switch (field) { + case PIDS: + return isSetPids(); + } + throw new IllegalStateException(); } - this.success = __this__success; - } - } - public checkURLs_result deepCopy() { - return new checkURLs_result(this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deletePackages_args) + return this.equals((deletePackages_args) that); + return false; + } - @Override - public void clear() { - this.success = null; - } + public boolean equals(deletePackages_args that) { + if (that == null) + return false; - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + boolean this_present_pids = true && this.isSetPids(); + boolean that_present_pids = true && that.isSetPids(); + if (this_present_pids || that_present_pids) { + if (!(this_present_pids && that_present_pids)) + return false; + if (!this.pids.equals(that.pids)) + return false; + } - public void putToSuccess(String key, List<String> val) { - if (this.success == null) { - this.success = new HashMap<String,List<String>>(); - } - this.success.put(key, val); - } + return true; + } - public Map<String,List<String>> getSuccess() { - return this.success; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public checkURLs_result setSuccess(Map<String,List<String>> success) { - this.success = success; - return this; - } + boolean present_pids = true && (isSetPids()); + list.add(present_pids); + if (present_pids) + list.add(pids); - public void unsetSuccess() { - this.success = null; - } + return list.hashCode(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + @Override + public int compareTo(deletePackages_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + int lastComparison = 0; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,List<String>>)value); + lastComparison = Boolean.valueOf(isSetPids()).compareTo(other.isSetPids()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPids()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pids, other.pids); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; } - break; - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deletePackages_args("); + boolean first = true; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkURLs_result) - return this.equals((checkURLs_result)that); - return false; - } + sb.append("pids:"); + if (this.pids == null) { + sb.append("null"); + } else { + sb.append(this.pids); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public boolean equals(checkURLs_result that) { - if (that == null) - return false; + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - 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; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - return true; - } + 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); + } + } - @Override - public int hashCode() { - return 0; - } + private static class deletePackages_argsStandardSchemeFactory implements SchemeFactory { + public deletePackages_argsStandardScheme getScheme() { + return new deletePackages_argsStandardScheme(); + } + } - public int compareTo(checkURLs_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkURLs_result typedOther = (checkURLs_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static class deletePackages_argsStandardScheme extends StandardScheme<deletePackages_args> { - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, deletePackages_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: // PIDS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list298 = iprot.readListBegin(); + struct.pids = new ArrayList<Integer>(_list298.size); + int _elem299; + for (int _i300 = 0; _i300 < _list298.size; ++_i300) { + _elem299 = iprot.readI32(); + struct.pids.add(_elem299); + } + iprot.readListEnd(); + } + struct.setPidsIsSet(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(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + // 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) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } - - @Override - public String toString() { - StringBuilder sb = new StringBuilder("checkURLs_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 write(org.apache.thrift.protocol.TProtocol oprot, deletePackages_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.pids != null) { + oprot.writeFieldBegin(PIDS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.pids.size())); + for (int _iter301 : struct.pids) { + oprot.writeI32(_iter301); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + } - 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.getMessage()); - } - } + private static class deletePackages_argsTupleSchemeFactory implements SchemeFactory { + public deletePackages_argsTupleScheme getScheme() { + return new deletePackages_argsTupleScheme(); + } + } - private static class checkURLs_resultStandardSchemeFactory implements SchemeFactory { - public checkURLs_resultStandardScheme getScheme() { - return new checkURLs_resultStandardScheme(); - } - } + private static class deletePackages_argsTupleScheme extends TupleScheme<deletePackages_args> { - private static class checkURLs_resultStandardScheme extends StandardScheme<checkURLs_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkURLs_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 _map122 = iprot.readMapBegin(); - struct.success = new HashMap<String,List<String>>(2*_map122.size); - for (int _i123 = 0; _i123 < _map122.size; ++_i123) - { - String _key124; // required - List<String> _val125; // required - _key124 = iprot.readString(); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deletePackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPids()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPids()) { { - org.apache.thrift.protocol.TList _list126 = iprot.readListBegin(); - _val125 = new ArrayList<String>(_list126.size); - for (int _i127 = 0; _i127 < _list126.size; ++_i127) - { - String _elem128; // required - _elem128 = iprot.readString(); - _val125.add(_elem128); - } - iprot.readListEnd(); - } - struct.success.put(_key124, _val125); - } - iprot.readMapEnd(); - } - 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, checkURLs_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.LIST, struct.success.size())); - for (Map.Entry<String, List<String>> _iter129 : struct.success.entrySet()) - { - oprot.writeString(_iter129.getKey()); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter129.getValue().size())); - for (String _iter130 : _iter129.getValue()) - { - oprot.writeString(_iter130); - } - oprot.writeListEnd(); - } - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } + oprot.writeI32(struct.pids.size()); + for (int _iter302 : struct.pids) { + oprot.writeI32(_iter302); + } + } + } + } - private static class checkURLs_resultTupleSchemeFactory implements SchemeFactory { - public checkURLs_resultTupleScheme getScheme() { - return new checkURLs_resultTupleScheme(); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deletePackages_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list303 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.pids = new ArrayList<Integer>(_list303.size); + int _elem304; + for (int _i305 = 0; _i305 < _list303.size; ++_i305) { + _elem304 = iprot.readI32(); + struct.pids.add(_elem304); + } + } + struct.setPidsIsSet(true); + } + } + } - private static class checkURLs_resultTupleScheme extends TupleScheme<checkURLs_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkURLs_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, List<String>> _iter131 : struct.success.entrySet()) - { - oprot.writeString(_iter131.getKey()); - { - oprot.writeI32(_iter131.getValue().size()); - for (String _iter132 : _iter131.getValue()) - { - oprot.writeString(_iter132); - } - } - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkURLs_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map133 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); - struct.success = new HashMap<String,List<String>>(2*_map133.size); - for (int _i134 = 0; _i134 < _map133.size; ++_i134) - { - String _key135; // required - List<String> _val136; // required - _key135 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list137 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val136 = new ArrayList<String>(_list137.size); - for (int _i138 = 0; _i138 < _list137.size; ++_i138) - { - String _elem139; // required - _elem139 = iprot.readString(); - _val136.add(_elem139); - } - } - struct.success.put(_key135, _val136); - } - } - struct.setSuccessIsSet(true); - } - } } - } + public static class deletePackages_result implements org.apache.thrift.TBase<deletePackages_result, deletePackages_result._Fields>, java.io.Serializable, Cloneable, Comparable<deletePackages_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deletePackages_result"); - public static class parseURLs_args implements org.apache.thrift.TBase<parseURLs_args, parseURLs_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("parseURLs_args"); - private static final org.apache.thrift.protocol.TField HTML_FIELD_DESC = new org.apache.thrift.protocol.TField("html", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField URL_FIELD_DESC = new org.apache.thrift.protocol.TField("url", org.apache.thrift.protocol.TType.STRING, (short)2); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new parseURLs_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new parseURLs_argsTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new deletePackages_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deletePackages_resultTupleSchemeFactory()); + } - public String html; // required - public String url; // 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 { - HTML((short)1, "html"), - URL((short)2, "url"); - - 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: // HTML - return HTML; - case 2: // URL - return URL; - default: - return null; - } - } - - /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. - */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.HTML, new org.apache.thrift.meta_data.FieldMetaData("html", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.URL, new org.apache.thrift.meta_data.FieldMetaData("url", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(parseURLs_args.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public parseURLs_args() { - } + @Override + public int describeContents() { + return 0; + } - public parseURLs_args( - String html, - String url) - { - this(); - this.html = html; - this.url = url; - } + public deletePackages_result(android.os.Parcel in) { + } - /** - * Performs a deep copy on <i>other</i>. - */ - public parseURLs_args(parseURLs_args other) { - if (other.isSetHtml()) { - this.html = other.html; - } - if (other.isSetUrl()) { - this.url = other.url; - } - } + public static final android.os.Parcelable.Creator<deletePackages_result> CREATOR = new android.os.Parcelable.Creator<deletePackages_result>() { + @Override + public deletePackages_result[] newArray(int size) { + return new deletePackages_result[size]; + } - public parseURLs_args deepCopy() { - return new parseURLs_args(this); - } + @Override + public deletePackages_result createFromParcel(android.os.Parcel in) { + return new deletePackages_result(in); + } + }; - @Override - public void clear() { - this.html = null; - this.url = null; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public String getHtml() { - return this.html; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public parseURLs_args setHtml(String html) { - this.html = html; - return this; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void unsetHtml() { - this.html = null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - /** Returns true if field html is set (has been assigned a value) and false otherwise */ - public boolean isSetHtml() { - return this.html != 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; + } - public void setHtmlIsSet(boolean value) { - if (!value) { - this.html = null; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public String getUrl() { - return this.url; - } + private final short _thriftId; + private final String _fieldName; - public parseURLs_args setUrl(String url) { - this.url = url; - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetUrl() { - this.url = null; - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field url is set (has been assigned a value) and false otherwise */ - public boolean isSetUrl() { - return this.url != null; - } + public String getFieldName() { + return _fieldName; + } + } - public void setUrlIsSet(boolean value) { - if (!value) { - this.url = null; - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case HTML: - if (value == null) { - unsetHtml(); - } else { - setHtml((String)value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deletePackages_result.class, metaDataMap); } - break; - case URL: - if (value == null) { - unsetUrl(); - } else { - setUrl((String)value); + public deletePackages_result() { } - break; - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case HTML: - return getHtml(); - - case URL: - return getUrl(); + /** + * Performs a deep copy on <i>other</i>. + */ + public deletePackages_result(deletePackages_result other) { + } - } - throw new IllegalStateException(); - } + public deletePackages_result deepCopy() { + return new deletePackages_result(this); + } - /** 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 HTML: - return isSetHtml(); - case URL: - return isSetUrl(); - } - throw new IllegalStateException(); - } + @Override + public void clear() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof parseURLs_args) - return this.equals((parseURLs_args)that); - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public boolean equals(parseURLs_args that) { - if (that == null) - return false; - - boolean this_present_html = true && this.isSetHtml(); - boolean that_present_html = true && that.isSetHtml(); - if (this_present_html || that_present_html) { - if (!(this_present_html && that_present_html)) - return false; - if (!this.html.equals(that.html)) - return false; - } - - boolean this_present_url = true && this.isSetUrl(); - boolean that_present_url = true && that.isSetUrl(); - if (this_present_url || that_present_url) { - if (!(this_present_url && that_present_url)) - return false; - if (!this.url.equals(that.url)) - return false; - } - - return true; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + /** 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(); + } - public int compareTo(parseURLs_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - parseURLs_args typedOther = (parseURLs_args)other; - - lastComparison = Boolean.valueOf(isSetHtml()).compareTo(typedOther.isSetHtml()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetHtml()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.html, typedOther.html); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetUrl()).compareTo(typedOther.isSetUrl()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUrl()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.url, typedOther.url); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + switch (field) { + } + throw new IllegalStateException(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deletePackages_result) + return this.equals((deletePackages_result) that); + return false; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public boolean equals(deletePackages_result that) { + if (that == null) + return false; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + return true; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("parseURLs_args("); - boolean first = true; - - sb.append("html:"); - if (this.html == null) { - sb.append("null"); - } else { - sb.append(this.html); - } - first = false; - if (!first) sb.append(", "); - sb.append("url:"); - if (this.url == null) { - sb.append("null"); - } else { - sb.append(this.url); - } - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(deletePackages_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - 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.getMessage()); - } - } + int lastComparison = 0; - private static class parseURLs_argsStandardSchemeFactory implements SchemeFactory { - public parseURLs_argsStandardScheme getScheme() { - return new parseURLs_argsStandardScheme(); - } - } + return 0; + } - private static class parseURLs_argsStandardScheme extends StandardScheme<parseURLs_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, parseURLs_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: // HTML - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.html = iprot.readString(); - struct.setHtmlIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // URL - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.url = iprot.readString(); - struct.setUrlIsSet(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, parseURLs_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.html != null) { - oprot.writeFieldBegin(HTML_FIELD_DESC); - oprot.writeString(struct.html); - oprot.writeFieldEnd(); - } - if (struct.url != null) { - oprot.writeFieldBegin(URL_FIELD_DESC); - oprot.writeString(struct.url); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class parseURLs_argsTupleSchemeFactory implements SchemeFactory { - public parseURLs_argsTupleScheme getScheme() { - return new parseURLs_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class parseURLs_argsTupleScheme extends TupleScheme<parseURLs_args> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deletePackages_result("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, parseURLs_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetHtml()) { - optionals.set(0); + sb.append(")"); + return sb.toString(); } - if (struct.isSetUrl()) { - optionals.set(1); + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - oprot.writeBitSet(optionals, 2); - if (struct.isSetHtml()) { - oprot.writeString(struct.html); + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - if (struct.isSetUrl()) { - oprot.writeString(struct.url); + + 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); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, parseURLs_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.html = iprot.readString(); - struct.setHtmlIsSet(true); + private static class deletePackages_resultStandardSchemeFactory implements SchemeFactory { + public deletePackages_resultStandardScheme getScheme() { + return new deletePackages_resultStandardScheme(); + } } - if (incoming.get(1)) { - struct.url = iprot.readString(); - struct.setUrlIsSet(true); + + private static class deletePackages_resultStandardScheme extends StandardScheme<deletePackages_result> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, deletePackages_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) { + 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, deletePackages_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + } - } - } - } + private static class deletePackages_resultTupleSchemeFactory implements SchemeFactory { + public deletePackages_resultTupleScheme getScheme() { + return new deletePackages_resultTupleScheme(); + } + } - public static class parseURLs_result implements org.apache.thrift.TBase<parseURLs_result, parseURLs_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("parseURLs_result"); + private static class deletePackages_resultTupleScheme extends TupleScheme<deletePackages_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); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deletePackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new parseURLs_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new parseURLs_resultTupleSchemeFactory()); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deletePackages_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public Map<String,List<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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(parseURLs_result.class, metaDataMap); - } + public static class pushToQueue_args implements org.apache.thrift.TBase<pushToQueue_args, pushToQueue_args._Fields>, java.io.Serializable, Cloneable, Comparable<pushToQueue_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pushToQueue_args"); - public parseURLs_result() { - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - public parseURLs_result( - Map<String,List<String>> success) - { - this(); - this.success = success; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** - * Performs a deep copy on <i>other</i>. - */ - public parseURLs_result(parseURLs_result other) { - if (other.isSetSuccess()) { - Map<String,List<String>> __this__success = new HashMap<String,List<String>>(); - for (Map.Entry<String, List<String>> other_element : other.success.entrySet()) { + static { + schemes.put(StandardScheme.class, new pushToQueue_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pushToQueue_argsTupleSchemeFactory()); + } - String other_element_key = other_element.getKey(); - List<String> other_element_value = other_element.getValue(); + public int pid; // required - String __this__success_copy_key = other_element_key; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - List<String> __this__success_copy_value = other_element_value; + out.writeInt(pid); + } - __this__success.put(__this__success_copy_key, __this__success_copy_value); + @Override + public int describeContents() { + return 0; } - this.success = __this__success; - } - } - public parseURLs_result deepCopy() { - return new parseURLs_result(this); - } + public pushToQueue_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - @Override - public void clear() { - this.success = null; - } + this.pid = in.readInt(); + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public static final android.os.Parcelable.Creator<pushToQueue_args> CREATOR = new android.os.Parcelable.Creator<pushToQueue_args>() { + @Override + public pushToQueue_args[] newArray(int size) { + return new pushToQueue_args[size]; + } - public void putToSuccess(String key, List<String> val) { - if (this.success == null) { - this.success = new HashMap<String,List<String>>(); - } - this.success.put(key, val); - } + @Override + public pushToQueue_args createFromParcel(android.os.Parcel in) { + return new pushToQueue_args(in); + } + }; - public Map<String,List<String>> getSuccess() { - return this.success; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - public parseURLs_result setSuccess(Map<String,List<String>> success) { - this.success = success; - return this; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void unsetSuccess() { - this.success = null; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = 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; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,List<String>>)value); - } - break; + /** + * 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; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - } - throw new IllegalStateException(); - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof parseURLs_result) - return this.equals((parseURLs_result)that); - return false; - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public boolean equals(parseURLs_result that) { - if (that == null) - return false; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pushToQueue_args.class, metaDataMap); + } - 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; - } + public pushToQueue_args() { + } - return true; - } + public pushToQueue_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } - @Override - public int hashCode() { - return 0; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public pushToQueue_args(pushToQueue_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } - public int compareTo(parseURLs_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - parseURLs_result typedOther = (parseURLs_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public pushToQueue_args deepCopy() { + return new pushToQueue_args(this); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public int getPid() { + return this.pid; + } - 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("parseURLs_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 pushToQueue_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - 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.getMessage()); - } - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - private static class parseURLs_resultStandardSchemeFactory implements SchemeFactory { - public parseURLs_resultStandardScheme getScheme() { - return new parseURLs_resultStandardScheme(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - private static class parseURLs_resultStandardScheme extends StandardScheme<parseURLs_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, parseURLs_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 _map140 = iprot.readMapBegin(); - struct.success = new HashMap<String,List<String>>(2*_map140.size); - for (int _i141 = 0; _i141 < _map140.size; ++_i141) - { - String _key142; // required - List<String> _val143; // required - _key142 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list144 = iprot.readListBegin(); - _val143 = new ArrayList<String>(_list144.size); - for (int _i145 = 0; _i145 < _list144.size; ++_i145) - { - String _elem146; // required - _elem146 = iprot.readString(); - _val143.add(_elem146); - } - iprot.readListEnd(); - } - struct.success.put(_key142, _val143); - } - iprot.readMapEnd(); - } - 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, parseURLs_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.LIST, struct.success.size())); - for (Map.Entry<String, List<String>> _iter147 : struct.success.entrySet()) - { - oprot.writeString(_iter147.getKey()); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, _iter147.getValue().size())); - for (String _iter148 : _iter147.getValue()) - { - oprot.writeString(_iter148); - } - oprot.writeListEnd(); - } - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - private static class parseURLs_resultTupleSchemeFactory implements SchemeFactory { - public parseURLs_resultTupleScheme getScheme() { - return new parseURLs_resultTupleScheme(); - } - } + } + throw new IllegalStateException(); + } - private static class parseURLs_resultTupleScheme extends TupleScheme<parseURLs_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, parseURLs_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, List<String>> _iter149 : struct.success.entrySet()) - { - oprot.writeString(_iter149.getKey()); - { - oprot.writeI32(_iter149.getValue().size()); - for (String _iter150 : _iter149.getValue()) - { - oprot.writeString(_iter150); - } - } - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, parseURLs_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map151 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.LIST, iprot.readI32()); - struct.success = new HashMap<String,List<String>>(2*_map151.size); - for (int _i152 = 0; _i152 < _map151.size; ++_i152) - { - String _key153; // required - List<String> _val154; // required - _key153 = iprot.readString(); - { - org.apache.thrift.protocol.TList _list155 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val154 = new ArrayList<String>(_list155.size); - for (int _i156 = 0; _i156 < _list155.size; ++_i156) - { - String _elem157; // required - _elem157 = iprot.readString(); - _val154.add(_elem157); - } - } - struct.success.put(_key153, _val154); - } - } - struct.setSuccessIsSet(true); - } - } - } + /** 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 PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - public static class checkOnlineStatus_args implements org.apache.thrift.TBase<checkOnlineStatus_args, checkOnlineStatus_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatus_args"); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pushToQueue_args) + return this.equals((pushToQueue_args) that); + return false; + } - private static final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short)1); + public boolean equals(pushToQueue_args that) { + if (that == null) + return false; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkOnlineStatus_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkOnlineStatus_argsTupleSchemeFactory()); - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - public List<String> urls; // 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 { - URLS((short)1, "urls"); - - 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: // URLS - return URLS; - 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; - } - } + return true; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatus_args.class, metaDataMap); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public checkOnlineStatus_args() { - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public checkOnlineStatus_args( - List<String> urls) - { - this(); - this.urls = urls; - } + return list.hashCode(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public checkOnlineStatus_args(checkOnlineStatus_args other) { - if (other.isSetUrls()) { - this.urls = other.urls; - } - } + @Override + public int compareTo(pushToQueue_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public checkOnlineStatus_args deepCopy() { - return new checkOnlineStatus_args(this); - } + int lastComparison = 0; - @Override - public void clear() { - this.urls = null; - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public int getUrlsSize() { - return (this.urls == null) ? 0 : this.urls.size(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public java.util.Iterator<String> getUrlsIterator() { - return (this.urls == null) ? null : this.urls.iterator(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void addToUrls(String elem) { - if (this.urls == null) { - this.urls = new ArrayList<String>(); - } - this.urls.add(elem); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public List<String> getUrls() { - return this.urls; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("pushToQueue_args("); + boolean first = true; - public checkOnlineStatus_args setUrls(List<String> urls) { - this.urls = urls; - return this; - } + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - public void unsetUrls() { - this.urls = null; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field urls is set (has been assigned a value) and false otherwise */ - public boolean isSetUrls() { - return this.urls != null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setUrlsIsSet(boolean value) { - if (!value) { - this.urls = null; - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case URLS: - if (value == null) { - unsetUrls(); - } else { - setUrls((List<String>)value); + private static class pushToQueue_argsStandardSchemeFactory implements SchemeFactory { + public pushToQueue_argsStandardScheme getScheme() { + return new pushToQueue_argsStandardScheme(); + } } - break; - } - } + private static class pushToQueue_argsStandardScheme extends StandardScheme<pushToQueue_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - case URLS: - return getUrls(); + public void read(org.apache.thrift.protocol.TProtocol iprot, pushToQueue_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** 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 URLS: - return isSetUrls(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, pushToQueue_args struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkOnlineStatus_args) - return this.equals((checkOnlineStatus_args)that); - return false; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public boolean equals(checkOnlineStatus_args that) { - if (that == null) - return false; + } - boolean this_present_urls = true && this.isSetUrls(); - boolean that_present_urls = true && that.isSetUrls(); - if (this_present_urls || that_present_urls) { - if (!(this_present_urls && that_present_urls)) - return false; - if (!this.urls.equals(that.urls)) - return false; - } + private static class pushToQueue_argsTupleSchemeFactory implements SchemeFactory { + public pushToQueue_argsTupleScheme getScheme() { + return new pushToQueue_argsTupleScheme(); + } + } - return true; - } + private static class pushToQueue_argsTupleScheme extends TupleScheme<pushToQueue_args> { - @Override - public int hashCode() { - return 0; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pushToQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - public int compareTo(checkOnlineStatus_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkOnlineStatus_args typedOther = (checkOnlineStatus_args)other; - - lastComparison = Boolean.valueOf(isSetUrls()).compareTo(typedOther.isSetUrls()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUrls()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, typedOther.urls); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pushToQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - 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 static class pushToQueue_result implements org.apache.thrift.TBase<pushToQueue_result, pushToQueue_result._Fields>, java.io.Serializable, Cloneable, Comparable<pushToQueue_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pushToQueue_result"); - 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("checkOnlineStatus_args("); - boolean first = true; - - sb.append("urls:"); - if (this.urls == null) { - sb.append("null"); - } else { - sb.append(this.urls); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + schemes.put(StandardScheme.class, new pushToQueue_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pushToQueue_resultTupleSchemeFactory()); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - 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.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - private static class checkOnlineStatus_argsStandardSchemeFactory implements SchemeFactory { - public checkOnlineStatus_argsStandardScheme getScheme() { - return new checkOnlineStatus_argsStandardScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class checkOnlineStatus_argsStandardScheme extends StandardScheme<checkOnlineStatus_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatus_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: // URLS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list158 = iprot.readListBegin(); - struct.urls = new ArrayList<String>(_list158.size); - for (int _i159 = 0; _i159 < _list158.size; ++_i159) - { - String _elem160; // required - _elem160 = iprot.readString(); - struct.urls.add(_elem160); - } - iprot.readListEnd(); - } - struct.setUrlsIsSet(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, checkOnlineStatus_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.urls != null) { - oprot.writeFieldBegin(URLS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); - for (String _iter161 : struct.urls) - { - oprot.writeString(_iter161); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public pushToQueue_result(android.os.Parcel in) { + } - } + public static final android.os.Parcelable.Creator<pushToQueue_result> CREATOR = new android.os.Parcelable.Creator<pushToQueue_result>() { + @Override + public pushToQueue_result[] newArray(int size) { + return new pushToQueue_result[size]; + } - private static class checkOnlineStatus_argsTupleSchemeFactory implements SchemeFactory { - public checkOnlineStatus_argsTupleScheme getScheme() { - return new checkOnlineStatus_argsTupleScheme(); - } - } + @Override + public pushToQueue_result createFromParcel(android.os.Parcel in) { + return new pushToQueue_result(in); + } + }; - private static class checkOnlineStatus_argsTupleScheme extends TupleScheme<checkOnlineStatus_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUrls()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetUrls()) { - { - oprot.writeI32(struct.urls.size()); - for (String _iter162 : struct.urls) - { - oprot.writeString(_iter162); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list163 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.urls = new ArrayList<String>(_list163.size); - for (int _i164 = 0; _i164 < _list163.size; ++_i164) - { - String _elem165; // required - _elem165 = iprot.readString(); - struct.urls.add(_elem165); - } - } - struct.setUrlsIsSet(true); - } - } - } + /** 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 Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public static class checkOnlineStatus_result implements org.apache.thrift.TBase<checkOnlineStatus_result, checkOnlineStatus_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatus_result"); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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); + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkOnlineStatus_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkOnlineStatus_resultTupleSchemeFactory()); - } + /** + * 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; + } - public OnlineCheck 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 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 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 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; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatus_result.class, metaDataMap); - } + private final short _thriftId; + private final String _fieldName; - public checkOnlineStatus_result() { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public checkOnlineStatus_result( - OnlineCheck success) - { - this(); - this.success = success; - } + public short getThriftFieldId() { + return _thriftId; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public checkOnlineStatus_result(checkOnlineStatus_result other) { - if (other.isSetSuccess()) { - this.success = new OnlineCheck(other.success); - } - } + public String getFieldName() { + return _fieldName; + } + } - public checkOnlineStatus_result deepCopy() { - return new checkOnlineStatus_result(this); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void clear() { - this.success = null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pushToQueue_result.class, metaDataMap); + } - public OnlineCheck getSuccess() { - return this.success; - } + public pushToQueue_result() { + } - public checkOnlineStatus_result setSuccess(OnlineCheck success) { - this.success = success; - return this; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public pushToQueue_result(pushToQueue_result other) { + } - public void unsetSuccess() { - this.success = null; - } + public pushToQueue_result deepCopy() { + return new pushToQueue_result(this); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + @Override + public void clear() { + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((OnlineCheck)value); + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); } - break; - } - } + /** 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(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + switch (field) { + } + throw new IllegalStateException(); + } - } - throw new IllegalStateException(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pushToQueue_result) + return this.equals((pushToQueue_result) that); + return false; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public boolean equals(pushToQueue_result that) { + if (that == null) + return false; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkOnlineStatus_result) - return this.equals((checkOnlineStatus_result)that); - return false; - } + return true; + } - public boolean equals(checkOnlineStatus_result that) { - if (that == null) - return false; + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - 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 list.hashCode(); + } - return true; - } + @Override + public int compareTo(pushToQueue_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public int hashCode() { - return 0; - } + int lastComparison = 0; - public int compareTo(checkOnlineStatus_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkOnlineStatus_result typedOther = (checkOnlineStatus_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + return 0; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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 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("checkOnlineStatus_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 write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("pushToQueue_result("); + boolean first = true; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + sb.append(")"); + return sb.toString(); + } - 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.getMessage()); - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static class checkOnlineStatus_resultStandardSchemeFactory implements SchemeFactory { - public checkOnlineStatus_resultStandardScheme getScheme() { - return new checkOnlineStatus_resultStandardScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(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 checkOnlineStatus_resultStandardScheme extends StandardScheme<checkOnlineStatus_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatus_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 OnlineCheck(); - struct.success.read(iprot); - 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, checkOnlineStatus_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static class pushToQueue_resultStandardSchemeFactory implements SchemeFactory { + public pushToQueue_resultStandardScheme getScheme() { + return new pushToQueue_resultStandardScheme(); + } + } - } + private static class pushToQueue_resultStandardScheme extends StandardScheme<pushToQueue_result> { - private static class checkOnlineStatus_resultTupleSchemeFactory implements SchemeFactory { - public checkOnlineStatus_resultTupleScheme getScheme() { - return new checkOnlineStatus_resultTupleScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, pushToQueue_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) { + 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(); + } - private static class checkOnlineStatus_resultTupleScheme extends TupleScheme<checkOnlineStatus_result> { + public void write(org.apache.thrift.protocol.TProtocol oprot, pushToQueue_result struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatus_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new OnlineCheck(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + private static class pushToQueue_resultTupleSchemeFactory implements SchemeFactory { + public pushToQueue_resultTupleScheme getScheme() { + return new pushToQueue_resultTupleScheme(); + } } - } - } - } + private static class pushToQueue_resultTupleScheme extends TupleScheme<pushToQueue_result> { - public static class checkOnlineStatusContainer_args implements org.apache.thrift.TBase<checkOnlineStatusContainer_args, checkOnlineStatusContainer_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatusContainer_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pushToQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private static final org.apache.thrift.protocol.TField URLS_FIELD_DESC = new org.apache.thrift.protocol.TField("urls", org.apache.thrift.protocol.TType.LIST, (short)1); - private static final org.apache.thrift.protocol.TField FILENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("filename", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short)3); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pushToQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkOnlineStatusContainer_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkOnlineStatusContainer_argsTupleSchemeFactory()); } - public List<String> urls; // required - public String filename; // required - public ByteBuffer data; // 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 { - URLS((short)1, "urls"), - FILENAME((short)2, "filename"), - DATA((short)3, "data"); - - 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: // URLS - return URLS; - case 2: // FILENAME - return FILENAME; - case 3: // DATA - return DATA; - 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; - } - } + public static class pullFromQueue_args implements org.apache.thrift.TBase<pullFromQueue_args, pullFromQueue_args._Fields>, java.io.Serializable, Cloneable, Comparable<pullFromQueue_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pullFromQueue_args"); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.URLS, new org.apache.thrift.meta_data.FieldMetaData("urls", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - tmpMap.put(_Fields.FILENAME, new org.apache.thrift.meta_data.FieldMetaData("filename", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatusContainer_args.class, metaDataMap); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - public checkOnlineStatusContainer_args() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public checkOnlineStatusContainer_args( - List<String> urls, - String filename, - ByteBuffer data) - { - this(); - this.urls = urls; - this.filename = filename; - this.data = data; - } + static { + schemes.put(StandardScheme.class, new pullFromQueue_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pullFromQueue_argsTupleSchemeFactory()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public checkOnlineStatusContainer_args(checkOnlineStatusContainer_args other) { - if (other.isSetUrls()) { - this.urls = other.urls; - } - if (other.isSetFilename()) { - this.filename = other.filename; - } - if (other.isSetData()) { - this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); -; - } - } + public int pid; // required - public checkOnlineStatusContainer_args deepCopy() { - return new checkOnlineStatusContainer_args(this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void clear() { - this.urls = null; - this.filename = null; - this.data = null; - } + out.writeInt(pid); + } - public int getUrlsSize() { - return (this.urls == null) ? 0 : this.urls.size(); - } + @Override + public int describeContents() { + return 0; + } - public java.util.Iterator<String> getUrlsIterator() { - return (this.urls == null) ? null : this.urls.iterator(); - } + public pullFromQueue_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void addToUrls(String elem) { - if (this.urls == null) { - this.urls = new ArrayList<String>(); - } - this.urls.add(elem); - } + this.pid = in.readInt(); + } - public List<String> getUrls() { - return this.urls; - } + public static final android.os.Parcelable.Creator<pullFromQueue_args> CREATOR = new android.os.Parcelable.Creator<pullFromQueue_args>() { + @Override + public pullFromQueue_args[] newArray(int size) { + return new pullFromQueue_args[size]; + } - public checkOnlineStatusContainer_args setUrls(List<String> urls) { - this.urls = urls; - return this; - } + @Override + public pullFromQueue_args createFromParcel(android.os.Parcel in) { + return new pullFromQueue_args(in); + } + }; - public void unsetUrls() { - this.urls = null; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - /** Returns true if field urls is set (has been assigned a value) and false otherwise */ - public boolean isSetUrls() { - return this.urls != null; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void setUrlsIsSet(boolean value) { - if (!value) { - this.urls = null; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public String getFilename() { - return this.filename; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - public checkOnlineStatusContainer_args setFilename(String filename) { - this.filename = filename; - return this; - } + /** + * 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; + } - public void unsetFilename() { - this.filename = null; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** Returns true if field filename is set (has been assigned a value) and false otherwise */ - public boolean isSetFilename() { - return this.filename != null; - } + private final short _thriftId; + private final String _fieldName; - public void setFilenameIsSet(boolean value) { - if (!value) { - this.filename = null; - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public byte[] getData() { - setData(org.apache.thrift.TBaseHelper.rightSize(data)); - return data == null ? null : data.array(); - } + public short getThriftFieldId() { + return _thriftId; + } - public ByteBuffer bufferForData() { - return data; - } + public String getFieldName() { + return _fieldName; + } + } - public checkOnlineStatusContainer_args setData(byte[] data) { - setData(data == null ? (ByteBuffer)null : ByteBuffer.wrap(data)); - return this; - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public checkOnlineStatusContainer_args setData(ByteBuffer data) { - this.data = data; - return this; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pullFromQueue_args.class, metaDataMap); + } - public void unsetData() { - this.data = null; - } + public pullFromQueue_args() { + } - /** Returns true if field data is set (has been assigned a value) and false otherwise */ - public boolean isSetData() { - return this.data != null; - } + public pullFromQueue_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } - public void setDataIsSet(boolean value) { - if (!value) { - this.data = null; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public pullFromQueue_args(pullFromQueue_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case URLS: - if (value == null) { - unsetUrls(); - } else { - setUrls((List<String>)value); + public pullFromQueue_args deepCopy() { + return new pullFromQueue_args(this); } - break; - case FILENAME: - if (value == null) { - unsetFilename(); - } else { - setFilename((String)value); + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; } - break; - case DATA: - if (value == null) { - unsetData(); - } else { - setData((ByteBuffer)value); + public int getPid() { + return this.pid; } - break; - } - } + public pullFromQueue_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case URLS: - return getUrls(); + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - case FILENAME: - return getFilename(); + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - case DATA: - return getData(); + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - } - throw new IllegalStateException(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - /** 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 URLS: - return isSetUrls(); - case FILENAME: - return isSetFilename(); - case DATA: - return isSetData(); - } - throw new IllegalStateException(); - } + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkOnlineStatusContainer_args) - return this.equals((checkOnlineStatusContainer_args)that); - return false; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - public boolean equals(checkOnlineStatusContainer_args that) { - if (that == null) - return false; - - boolean this_present_urls = true && this.isSetUrls(); - boolean that_present_urls = true && that.isSetUrls(); - if (this_present_urls || that_present_urls) { - if (!(this_present_urls && that_present_urls)) - return false; - if (!this.urls.equals(that.urls)) - return false; - } - - boolean this_present_filename = true && this.isSetFilename(); - boolean that_present_filename = true && that.isSetFilename(); - if (this_present_filename || that_present_filename) { - if (!(this_present_filename && that_present_filename)) - return false; - if (!this.filename.equals(that.filename)) - return false; - } - - boolean this_present_data = true && this.isSetData(); - boolean that_present_data = true && that.isSetData(); - if (this_present_data || that_present_data) { - if (!(this_present_data && that_present_data)) - return false; - if (!this.data.equals(that.data)) - return false; - } - - return true; - } + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + /** 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(); + } - public int compareTo(checkOnlineStatusContainer_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkOnlineStatusContainer_args typedOther = (checkOnlineStatusContainer_args)other; - - lastComparison = Boolean.valueOf(isSetUrls()).compareTo(typedOther.isSetUrls()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUrls()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.urls, typedOther.urls); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFilename()).compareTo(typedOther.isSetFilename()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFilename()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filename, typedOther.filename); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetData()).compareTo(typedOther.isSetData()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetData()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, typedOther.data); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + switch (field) { + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pullFromQueue_args) + return this.equals((pullFromQueue_args) that); + return false; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public boolean equals(pullFromQueue_args that) { + if (that == null) + return false; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("checkOnlineStatusContainer_args("); - boolean first = true; - - sb.append("urls:"); - if (this.urls == null) { - sb.append("null"); - } else { - sb.append(this.urls); - } - first = false; - if (!first) sb.append(", "); - sb.append("filename:"); - if (this.filename == null) { - sb.append("null"); - } else { - sb.append(this.filename); - } - first = false; - if (!first) sb.append(", "); - sb.append("data:"); - if (this.data == null) { - sb.append("null"); - } else { - org.apache.thrift.TBaseHelper.toString(this.data, sb); - } - first = false; - sb.append(")"); - return sb.toString(); - } + return true; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - 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.getMessage()); - } - } + return list.hashCode(); + } - private static class checkOnlineStatusContainer_argsStandardSchemeFactory implements SchemeFactory { - public checkOnlineStatusContainer_argsStandardScheme getScheme() { - return new checkOnlineStatusContainer_argsStandardScheme(); - } - } + @Override + public int compareTo(pullFromQueue_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class checkOnlineStatusContainer_argsStandardScheme extends StandardScheme<checkOnlineStatusContainer_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatusContainer_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: // URLS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list166 = iprot.readListBegin(); - struct.urls = new ArrayList<String>(_list166.size); - for (int _i167 = 0; _i167 < _list166.size; ++_i167) - { - String _elem168; // required - _elem168 = iprot.readString(); - struct.urls.add(_elem168); - } - iprot.readListEnd(); - } - struct.setUrlsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // FILENAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.filename = iprot.readString(); - struct.setFilenameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 3: // DATA - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(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, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.urls != null) { - oprot.writeFieldBegin(URLS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.urls.size())); - for (String _iter169 : struct.urls) - { - oprot.writeString(_iter169); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - if (struct.filename != null) { - oprot.writeFieldBegin(FILENAME_FIELD_DESC); - oprot.writeString(struct.filename); - oprot.writeFieldEnd(); - } - if (struct.data != null) { - oprot.writeFieldBegin(DATA_FIELD_DESC); - oprot.writeBinary(struct.data); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + int lastComparison = 0; - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - private static class checkOnlineStatusContainer_argsTupleSchemeFactory implements SchemeFactory { - public checkOnlineStatusContainer_argsTupleScheme getScheme() { - return new checkOnlineStatusContainer_argsTupleScheme(); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class checkOnlineStatusContainer_argsTupleScheme extends TupleScheme<checkOnlineStatusContainer_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUrls()) { - optionals.set(0); - } - if (struct.isSetFilename()) { - optionals.set(1); - } - if (struct.isSetData()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); - if (struct.isSetUrls()) { - { - oprot.writeI32(struct.urls.size()); - for (String _iter170 : struct.urls) - { - oprot.writeString(_iter170); - } - } - } - if (struct.isSetFilename()) { - oprot.writeString(struct.filename); - } - if (struct.isSetData()) { - oprot.writeBinary(struct.data); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list171 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.urls = new ArrayList<String>(_list171.size); - for (int _i172 = 0; _i172 < _list171.size; ++_i172) - { - String _elem173; // required - _elem173 = iprot.readString(); - struct.urls.add(_elem173); - } - } - struct.setUrlsIsSet(true); - } - if (incoming.get(1)) { - struct.filename = iprot.readString(); - struct.setFilenameIsSet(true); - } - if (incoming.get(2)) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(true); - } - } - } + 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); + } - public static class checkOnlineStatusContainer_result implements org.apache.thrift.TBase<checkOnlineStatusContainer_result, checkOnlineStatusContainer_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("checkOnlineStatusContainer_result"); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("pullFromQueue_args("); + boolean first = true; - 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); + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new checkOnlineStatusContainer_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new checkOnlineStatusContainer_resultTupleSchemeFactory()); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public OnlineCheck 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 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 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 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; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(checkOnlineStatusContainer_result.class, metaDataMap); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public checkOnlineStatusContainer_result() { - } + private static class pullFromQueue_argsStandardSchemeFactory implements SchemeFactory { + public pullFromQueue_argsStandardScheme getScheme() { + return new pullFromQueue_argsStandardScheme(); + } + } - public checkOnlineStatusContainer_result( - OnlineCheck success) - { - this(); - this.success = success; - } + private static class pullFromQueue_argsStandardScheme extends StandardScheme<pullFromQueue_args> { - /** - * Performs a deep copy on <i>other</i>. - */ - public checkOnlineStatusContainer_result(checkOnlineStatusContainer_result other) { - if (other.isSetSuccess()) { - this.success = new OnlineCheck(other.success); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, pullFromQueue_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - public checkOnlineStatusContainer_result deepCopy() { - return new checkOnlineStatusContainer_result(this); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void clear() { - this.success = null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, pullFromQueue_args struct) throws org.apache.thrift.TException { + struct.validate(); - public OnlineCheck getSuccess() { - return this.success; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public checkOnlineStatusContainer_result setSuccess(OnlineCheck success) { - this.success = success; - return this; - } + } - public void unsetSuccess() { - this.success = null; - } + private static class pullFromQueue_argsTupleSchemeFactory implements SchemeFactory { + public pullFromQueue_argsTupleScheme getScheme() { + return new pullFromQueue_argsTupleScheme(); + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private static class pullFromQueue_argsTupleScheme extends TupleScheme<pullFromQueue_args> { - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((OnlineCheck)value); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } } - break; - } } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public static class pullFromQueue_result implements org.apache.thrift.TBase<pullFromQueue_result, pullFromQueue_result._Fields>, java.io.Serializable, Cloneable, Comparable<pullFromQueue_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pullFromQueue_result"); - } - throw new IllegalStateException(); - } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof checkOnlineStatusContainer_result) - return this.equals((checkOnlineStatusContainer_result)that); - return false; - } + static { + schemes.put(StandardScheme.class, new pullFromQueue_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new pullFromQueue_resultTupleSchemeFactory()); + } - public boolean equals(checkOnlineStatusContainer_result that) { - if (that == null) - return false; - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - return true; - } + @Override + public int describeContents() { + return 0; + } - @Override - public int hashCode() { - return 0; - } + public pullFromQueue_result(android.os.Parcel in) { + } - public int compareTo(checkOnlineStatusContainer_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - checkOnlineStatusContainer_result typedOther = (checkOnlineStatusContainer_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public static final android.os.Parcelable.Creator<pullFromQueue_result> CREATOR = new android.os.Parcelable.Creator<pullFromQueue_result>() { + @Override + public pullFromQueue_result[] newArray(int size) { + return new pullFromQueue_result[size]; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public pullFromQueue_result createFromParcel(android.os.Parcel in) { + return new pullFromQueue_result(in); + } + }; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public 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("checkOnlineStatusContainer_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(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - 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.getMessage()); - } - } + /** + * 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; + } - private static class checkOnlineStatusContainer_resultStandardSchemeFactory implements SchemeFactory { - public checkOnlineStatusContainer_resultStandardScheme getScheme() { - return new checkOnlineStatusContainer_resultStandardScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class checkOnlineStatusContainer_resultStandardScheme extends StandardScheme<checkOnlineStatusContainer_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, checkOnlineStatusContainer_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 OnlineCheck(); - struct.success.read(iprot); - 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, checkOnlineStatusContainer_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class checkOnlineStatusContainer_resultTupleSchemeFactory implements SchemeFactory { - public checkOnlineStatusContainer_resultTupleScheme getScheme() { - return new checkOnlineStatusContainer_resultTupleScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } - private static class checkOnlineStatusContainer_resultTupleScheme extends TupleScheme<checkOnlineStatusContainer_result> { + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pullFromQueue_result.class, metaDataMap); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + + public pullFromQueue_result() { } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, checkOnlineStatusContainer_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new OnlineCheck(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + /** + * Performs a deep copy on <i>other</i>. + */ + public pullFromQueue_result(pullFromQueue_result other) { } - } - } - } + public pullFromQueue_result deepCopy() { + return new pullFromQueue_result(this); + } - public static class pollResults_args implements org.apache.thrift.TBase<pollResults_args, pollResults_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pollResults_args"); + @Override + public void clear() { + } - private static final org.apache.thrift.protocol.TField RID_FIELD_DESC = new org.apache.thrift.protocol.TField("rid", org.apache.thrift.protocol.TType.I32, (short)1); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pollResults_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pollResults_argsTupleSchemeFactory()); - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public int rid; // 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 { - RID((short)1, "rid"); - - 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: // RID - return RID; - 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; - } - } + /** 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(); + } - // isset id assignments - private static final int __RID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.RID, new org.apache.thrift.meta_data.FieldMetaData("rid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "ResultID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pollResults_args.class, metaDataMap); - } + switch (field) { + } + throw new IllegalStateException(); + } - public pollResults_args() { - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof pullFromQueue_result) + return this.equals((pullFromQueue_result) that); + return false; + } - public pollResults_args( - int rid) - { - this(); - this.rid = rid; - setRidIsSet(true); - } + public boolean equals(pullFromQueue_result that) { + if (that == null) + return false; - /** - * Performs a deep copy on <i>other</i>. - */ - public pollResults_args(pollResults_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.rid = other.rid; - } + return true; + } - public pollResults_args deepCopy() { - return new pollResults_args(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - setRidIsSet(false); - this.rid = 0; - } + return list.hashCode(); + } - public int getRid() { - return this.rid; - } + @Override + public int compareTo(pullFromQueue_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public pollResults_args setRid(int rid) { - this.rid = rid; - setRidIsSet(true); - return this; - } + int lastComparison = 0; - public void unsetRid() { - __isset_bit_vector.clear(__RID_ISSET_ID); - } + return 0; + } - /** Returns true if field rid is set (has been assigned a value) and false otherwise */ - public boolean isSetRid() { - return __isset_bit_vector.get(__RID_ISSET_ID); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setRidIsSet(boolean value) { - __isset_bit_vector.set(__RID_ISSET_ID, value); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case RID: - if (value == null) { - unsetRid(); - } else { - setRid((Integer)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("pullFromQueue_result("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case RID: - return Integer.valueOf(getRid()); + sb.append(")"); + return sb.toString(); + } - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** 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 RID: - return isSetRid(); - } - throw new IllegalStateException(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pollResults_args) - return this.equals((pollResults_args)that); - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(pollResults_args that) { - if (that == null) - return false; + private static class pullFromQueue_resultStandardSchemeFactory implements SchemeFactory { + public pullFromQueue_resultStandardScheme getScheme() { + return new pullFromQueue_resultStandardScheme(); + } + } - boolean this_present_rid = true; - boolean that_present_rid = true; - if (this_present_rid || that_present_rid) { - if (!(this_present_rid && that_present_rid)) - return false; - if (this.rid != that.rid) - return false; - } + private static class pullFromQueue_resultStandardScheme extends StandardScheme<pullFromQueue_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, pullFromQueue_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(pollResults_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - pollResults_args typedOther = (pollResults_args)other; - - lastComparison = Boolean.valueOf(isSetRid()).compareTo(typedOther.isSetRid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetRid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.rid, typedOther.rid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, pullFromQueue_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class pullFromQueue_resultTupleSchemeFactory implements SchemeFactory { + public pullFromQueue_resultTupleScheme getScheme() { + return new pullFromQueue_resultTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pollResults_args("); - boolean first = true; + private static class pullFromQueue_resultTupleScheme extends TupleScheme<pullFromQueue_result> { - sb.append("rid:"); - sb.append(this.rid); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public static class restartPackage_args implements org.apache.thrift.TBase<restartPackage_args, restartPackage_args._Fields>, java.io.Serializable, Cloneable, Comparable<restartPackage_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartPackage_args"); - private static class pollResults_argsStandardSchemeFactory implements SchemeFactory { - public pollResults_argsStandardScheme getScheme() { - return new pollResults_argsStandardScheme(); - } - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - private static class pollResults_argsStandardScheme extends StandardScheme<pollResults_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pollResults_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: // RID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.rid = iprot.readI32(); - struct.setRidIsSet(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, pollResults_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(RID_FIELD_DESC); - oprot.writeI32(struct.rid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - } + static { + schemes.put(StandardScheme.class, new restartPackage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartPackage_argsTupleSchemeFactory()); + } - private static class pollResults_argsTupleSchemeFactory implements SchemeFactory { - public pollResults_argsTupleScheme getScheme() { - return new pollResults_argsTupleScheme(); - } - } + public int pid; // required - private static class pollResults_argsTupleScheme extends TupleScheme<pollResults_args> { + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pollResults_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetRid()) { - optionals.set(0); + out.writeInt(pid); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetRid()) { - oprot.writeI32(struct.rid); + + @Override + public int describeContents() { + return 0; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pollResults_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.rid = iprot.readI32(); - struct.setRidIsSet(true); + public restartPackage_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.pid = in.readInt(); } - } - } - } + public static final android.os.Parcelable.Creator<restartPackage_args> CREATOR = new android.os.Parcelable.Creator<restartPackage_args>() { + @Override + public restartPackage_args[] newArray(int size) { + return new restartPackage_args[size]; + } - public static class pollResults_result implements org.apache.thrift.TBase<pollResults_result, pollResults_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pollResults_result"); + @Override + public restartPackage_args createFromParcel(android.os.Parcel in) { + return new restartPackage_args(in); + } + }; - 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); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pollResults_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pollResults_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public OnlineCheck 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 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 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 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, OnlineCheck.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pollResults_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - public pollResults_result() { - } + /** + * 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; + } - public pollResults_result( - OnlineCheck success) - { - this(); - this.success = success; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pollResults_result(pollResults_result other) { - if (other.isSetSuccess()) { - this.success = new OnlineCheck(other.success); - } - } + private final short _thriftId; + private final String _fieldName; - public pollResults_result deepCopy() { - return new pollResults_result(this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void clear() { - this.success = null; - } + public short getThriftFieldId() { + return _thriftId; + } - public OnlineCheck getSuccess() { - return this.success; - } + public String getFieldName() { + return _fieldName; + } + } - public pollResults_result setSuccess(OnlineCheck success) { - this.success = success; - return this; - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartPackage_args.class, metaDataMap); + } + + public restartPackage_args() { + } + + public restartPackage_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } - public void unsetSuccess() { - this.success = null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public restartPackage_args(restartPackage_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public restartPackage_args deepCopy() { + return new restartPackage_args(this); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((OnlineCheck)value); + public int getPid() { + return this.pid; } - break; - } - } + public restartPackage_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - } - throw new IllegalStateException(); - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pollResults_result) - return this.equals((pollResults_result)that); - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - public boolean equals(pollResults_result that) { - if (that == null) - return false; + } + } - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - return true; - } + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + /** 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(); + } - public int compareTo(pollResults_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - pollResults_result typedOther = (pollResults_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + switch (field) { + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartPackage_args) + return this.equals((restartPackage_args) that); + return false; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public boolean equals(restartPackage_args that) { + if (that == null) + return false; - 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("pollResults_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(); - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + return true; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - 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.getMessage()); - } - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - private static class pollResults_resultStandardSchemeFactory implements SchemeFactory { - public pollResults_resultStandardScheme getScheme() { - return new pollResults_resultStandardScheme(); - } - } + return list.hashCode(); + } - private static class pollResults_resultStandardScheme extends StandardScheme<pollResults_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pollResults_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 OnlineCheck(); - struct.success.read(iprot); - 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, pollResults_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public int compareTo(restartPackage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - } + int lastComparison = 0; - private static class pollResults_resultTupleSchemeFactory implements SchemeFactory { - public pollResults_resultTupleScheme getScheme() { - return new pollResults_resultTupleScheme(); - } - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - private static class pollResults_resultTupleScheme extends TupleScheme<pollResults_result> { + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pollResults_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pollResults_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new OnlineCheck(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartPackage_args("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); } - } - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public static class statusDownloads_args implements org.apache.thrift.TBase<statusDownloads_args, statusDownloads_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusDownloads_args"); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new statusDownloads_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new statusDownloads_argsTupleSchemeFactory()); - } + private static class restartPackage_argsStandardSchemeFactory implements SchemeFactory { + public restartPackage_argsStandardScheme getScheme() { + return new restartPackage_argsStandardScheme(); + } + } + private static class restartPackage_argsStandardScheme extends StandardScheme<restartPackage_args> { - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { -; - - 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusDownloads_args.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, restartPackage_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - public statusDownloads_args() { - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public statusDownloads_args(statusDownloads_args other) { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartPackage_args struct) throws org.apache.thrift.TException { + struct.validate(); - public statusDownloads_args deepCopy() { - return new statusDownloads_args(this); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void clear() { - } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class restartPackage_argsTupleSchemeFactory implements SchemeFactory { + public restartPackage_argsTupleScheme getScheme() { + return new restartPackage_argsTupleScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static class restartPackage_argsTupleScheme extends TupleScheme<restartPackage_args> { - /** 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(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof statusDownloads_args) - return this.equals((statusDownloads_args)that); - return false; } - public boolean equals(statusDownloads_args that) { - if (that == null) - return false; + public static class restartPackage_result implements org.apache.thrift.TBase<restartPackage_result, restartPackage_result._Fields>, java.io.Serializable, Cloneable, Comparable<restartPackage_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartPackage_result"); - return true; - } - @Override - public int hashCode() { - return 0; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public int compareTo(statusDownloads_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + static { + schemes.put(StandardScheme.class, new restartPackage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartPackage_resultTupleSchemeFactory()); + } - int lastComparison = 0; - statusDownloads_args typedOther = (statusDownloads_args)other; - return 0; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public int describeContents() { + return 0; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public restartPackage_result(android.os.Parcel in) { + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public static final android.os.Parcelable.Creator<restartPackage_result> CREATOR = new android.os.Parcelable.Creator<restartPackage_result>() { + @Override + public restartPackage_result[] newArray(int size) { + return new restartPackage_result[size]; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("statusDownloads_args("); - boolean first = true; + @Override + public restartPackage_result createFromParcel(android.os.Parcel in) { + return new restartPackage_result(in); + } + }; - sb.append(")"); - return sb.toString(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static class statusDownloads_argsStandardSchemeFactory implements SchemeFactory { - public statusDownloads_argsStandardScheme getScheme() { - return new statusDownloads_argsStandardScheme(); - } - } + /** + * 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; + } - private static class statusDownloads_argsStandardScheme extends StandardScheme<statusDownloads_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, statusDownloads_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, statusDownloads_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * 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; - private static class statusDownloads_argsTupleSchemeFactory implements SchemeFactory { - public statusDownloads_argsTupleScheme getScheme() { - return new statusDownloads_argsTupleScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class statusDownloads_argsTupleScheme extends TupleScheme<statusDownloads_args> { + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, statusDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, statusDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartPackage_result.class, metaDataMap); + } - public static class statusDownloads_result implements org.apache.thrift.TBase<statusDownloads_result, statusDownloads_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("statusDownloads_result"); + public restartPackage_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); + /** + * Performs a deep copy on <i>other</i>. + */ + public restartPackage_result(restartPackage_result other) { + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new statusDownloads_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new statusDownloads_resultTupleSchemeFactory()); - } + public restartPackage_result deepCopy() { + return new restartPackage_result(this); + } - public List<DownloadInfo> 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 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 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 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; - } - } + @Override + public void clear() { + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, DownloadInfo.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(statusDownloads_result.class, metaDataMap); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public statusDownloads_result() { - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public statusDownloads_result( - List<DownloadInfo> success) - { - this(); - this.success = success; - } + /** 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(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public statusDownloads_result(statusDownloads_result other) { - if (other.isSetSuccess()) { - List<DownloadInfo> __this__success = new ArrayList<DownloadInfo>(); - for (DownloadInfo other_element : other.success) { - __this__success.add(new DownloadInfo(other_element)); - } - this.success = __this__success; - } - } + switch (field) { + } + throw new IllegalStateException(); + } - public statusDownloads_result deepCopy() { - return new statusDownloads_result(this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartPackage_result) + return this.equals((restartPackage_result) that); + return false; + } - @Override - public void clear() { - this.success = null; - } + public boolean equals(restartPackage_result that) { + if (that == null) + return false; - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + return true; + } - public java.util.Iterator<DownloadInfo> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void addToSuccess(DownloadInfo elem) { - if (this.success == null) { - this.success = new ArrayList<DownloadInfo>(); - } - this.success.add(elem); - } + return list.hashCode(); + } - public List<DownloadInfo> getSuccess() { - return this.success; - } + @Override + public int compareTo(restartPackage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public statusDownloads_result setSuccess(List<DownloadInfo> success) { - this.success = success; - return this; - } + int lastComparison = 0; - public void unsetSuccess() { - this.success = null; - } + return 0; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<DownloadInfo>)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartPackage_result("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + sb.append(")"); + return sb.toString(); + } - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof statusDownloads_result) - return this.equals((statusDownloads_result)that); - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(statusDownloads_result that) { - if (that == null) - return false; + private static class restartPackage_resultStandardSchemeFactory implements SchemeFactory { + public restartPackage_resultStandardScheme getScheme() { + return new restartPackage_resultStandardScheme(); + } + } - 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; - } + private static class restartPackage_resultStandardScheme extends StandardScheme<restartPackage_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, restartPackage_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(statusDownloads_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - statusDownloads_result typedOther = (statusDownloads_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartPackage_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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("statusDownloads_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(); - } + private static class restartPackage_resultTupleSchemeFactory implements SchemeFactory { + public restartPackage_resultTupleScheme getScheme() { + return new restartPackage_resultTupleScheme(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class restartPackage_resultTupleScheme extends TupleScheme<restartPackage_result> { - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - 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.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static class statusDownloads_resultStandardSchemeFactory implements SchemeFactory { - public statusDownloads_resultStandardScheme getScheme() { - return new statusDownloads_resultStandardScheme(); - } } - private static class statusDownloads_resultStandardScheme extends StandardScheme<statusDownloads_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, statusDownloads_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 _list174 = iprot.readListBegin(); - struct.success = new ArrayList<DownloadInfo>(_list174.size); - for (int _i175 = 0; _i175 < _list174.size; ++_i175) - { - DownloadInfo _elem176; // required - _elem176 = new DownloadInfo(); - _elem176.read(iprot); - struct.success.add(_elem176); - } - iprot.readListEnd(); - } - 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, statusDownloads_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 (DownloadInfo _iter177 : struct.success) - { - _iter177.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public static class restartFile_args implements org.apache.thrift.TBase<restartFile_args, restartFile_args._Fields>, java.io.Serializable, Cloneable, Comparable<restartFile_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFile_args"); - } + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); - private static class statusDownloads_resultTupleSchemeFactory implements SchemeFactory { - public statusDownloads_resultTupleScheme getScheme() { - return new statusDownloads_resultTupleScheme(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class statusDownloads_resultTupleScheme extends TupleScheme<statusDownloads_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, statusDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (DownloadInfo _iter178 : struct.success) - { - _iter178.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, statusDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list179 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<DownloadInfo>(_list179.size); - for (int _i180 = 0; _i180 < _list179.size; ++_i180) - { - DownloadInfo _elem181; // required - _elem181 = new DownloadInfo(); - _elem181.read(iprot); - struct.success.add(_elem181); - } - } - struct.setSuccessIsSet(true); - } - } - } + static { + schemes.put(StandardScheme.class, new restartFile_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartFile_argsTupleSchemeFactory()); + } - } + public int fid; // required - public static class getPackageData_args implements org.apache.thrift.TBase<getPackageData_args, getPackageData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageData_args"); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + out.writeInt(fid); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageData_argsTupleSchemeFactory()); - } + @Override + public int describeContents() { + return 0; + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + public restartFile_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageData_args.class, metaDataMap); - } + this.fid = in.readInt(); + } - public getPackageData_args() { - } + public static final android.os.Parcelable.Creator<restartFile_args> CREATOR = new android.os.Parcelable.Creator<restartFile_args>() { + @Override + public restartFile_args[] newArray(int size) { + return new restartFile_args[size]; + } - public getPackageData_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + @Override + public restartFile_args createFromParcel(android.os.Parcel in) { + return new restartFile_args(in); + } + }; - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageData_args(getPackageData_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"); - public getPackageData_args deepCopy() { - return new getPackageData_args(this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int getPid() { - return this.pid; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FID + return FID; + default: + return null; + } + } - public getPackageData_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + /** + * 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; + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + private final short _thriftId; + private final String _fieldName; - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } } - break; - } - } + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFile_args.class, metaDataMap); + } - } - throw new IllegalStateException(); - } + public restartFile_args() { + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + public restartFile_args( + int fid) { + this(); + this.fid = fid; + setFidIsSet(true); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageData_args) - return this.equals((getPackageData_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public restartFile_args(restartFile_args other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; + } - public boolean equals(getPackageData_args that) { - if (that == null) - return false; + public restartFile_args deepCopy() { + return new restartFile_args(this); + } - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + } - return true; - } + public int getFid() { + return this.fid; + } - @Override - public int hashCode() { - return 0; - } + public restartFile_args setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; + } - public int compareTo(getPackageData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageData_args typedOther = (getPackageData_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getPackageData_args("); - boolean first = true; + } + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + } + throw new IllegalStateException(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** 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(); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + switch (field) { + case FID: + return isSetFid(); + } + throw new IllegalStateException(); + } - private static class getPackageData_argsStandardSchemeFactory implements SchemeFactory { - public getPackageData_argsStandardScheme getScheme() { - return new getPackageData_argsStandardScheme(); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartFile_args) + return this.equals((restartFile_args) that); + return false; + } - private static class getPackageData_argsStandardScheme extends StandardScheme<getPackageData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageData_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, getPackageData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public boolean equals(restartFile_args that) { + if (that == null) + return false; - } + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + return false; + } - private static class getPackageData_argsTupleSchemeFactory implements SchemeFactory { - public getPackageData_argsTupleScheme getScheme() { - return new getPackageData_argsTupleScheme(); - } - } + return true; + } - private static class getPackageData_argsTupleScheme extends TupleScheme<getPackageData_args> { + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - } + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + return list.hashCode(); } - } - } - - } - public static class getPackageData_result implements org.apache.thrift.TBase<getPackageData_result, getPackageData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageData_result"); + @Override + public int compareTo(restartFile_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - 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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short)1); + int lastComparison = 0; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageData_resultTupleSchemeFactory()); - } + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public PackageData success; // required - public PackageDoesNotExists e; // 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"), - E((short)1, "e"); - - 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 0: // SUCCESS - return SUCCESS; - case 1: // E - return E; - 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; - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class))); - tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageData_result.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public getPackageData_result() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public getPackageData_result( - PackageData success, - PackageDoesNotExists e) - { - this(); - this.success = success; - this.e = e; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartFile_args("); + boolean first = true; - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageData_result(getPackageData_result other) { - if (other.isSetSuccess()) { - this.success = new PackageData(other.success); - } - if (other.isSetE()) { - this.e = new PackageDoesNotExists(other.e); - } - } + sb.append("fid:"); + sb.append(this.fid); + first = false; + sb.append(")"); + return sb.toString(); + } - public getPackageData_result deepCopy() { - return new getPackageData_result(this); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public void clear() { - this.success = null; - this.e = null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public PackageData getSuccess() { - return this.success; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public getPackageData_result setSuccess(PackageData success) { - this.success = success; - return this; - } + private static class restartFile_argsStandardSchemeFactory implements SchemeFactory { + public restartFile_argsStandardScheme getScheme() { + return new restartFile_argsStandardScheme(); + } + } - public void unsetSuccess() { - this.success = null; - } + private static class restartFile_argsStandardScheme extends StandardScheme<restartFile_args> { - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, restartFile_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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(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(); - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public PackageDoesNotExists getE() { - return this.e; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartFile_args struct) throws org.apache.thrift.TException { + struct.validate(); - public getPackageData_result setE(PackageDoesNotExists e) { - this.e = e; - return this; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void unsetE() { - this.e = null; - } + } - /** Returns true if field e is set (has been assigned a value) and false otherwise */ - public boolean isSetE() { - return this.e != null; - } + private static class restartFile_argsTupleSchemeFactory implements SchemeFactory { + public restartFile_argsTupleScheme getScheme() { + return new restartFile_argsTupleScheme(); + } + } - public void setEIsSet(boolean value) { - if (!value) { - this.e = null; - } - } + private static class restartFile_argsTupleScheme extends TupleScheme<restartFile_args> { - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((PackageData)value); - } - break; + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartFile_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + } - case E: - if (value == null) { - unsetE(); - } else { - setE((PackageDoesNotExists)value); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartFile_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + } } - break; - } } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public static class restartFile_result implements org.apache.thrift.TBase<restartFile_result, restartFile_result._Fields>, java.io.Serializable, Cloneable, Comparable<restartFile_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFile_result"); - case E: - return getE(); - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - case E: - return isSetE(); - } - throw new IllegalStateException(); - } + static { + schemes.put(StandardScheme.class, new restartFile_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartFile_resultTupleSchemeFactory()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageData_result) - return this.equals((getPackageData_result)that); - return false; - } - public boolean equals(getPackageData_result that) { - if (that == null) - return false; - - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } - - boolean this_present_e = true && this.isSetE(); - boolean that_present_e = true && that.isSetE(); - if (this_present_e || that_present_e) { - if (!(this_present_e && that_present_e)) - return false; - if (!this.e.equals(that.e)) - return false; - } - - return true; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(getPackageData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageData_result typedOther = (getPackageData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetE()).compareTo(typedOther.isSetE()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetE()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, typedOther.e); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public restartFile_result(android.os.Parcel in) { + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static final android.os.Parcelable.Creator<restartFile_result> CREATOR = new android.os.Parcelable.Creator<restartFile_result>() { + @Override + public restartFile_result[] newArray(int size) { + return new restartFile_result[size]; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public restartFile_result createFromParcel(android.os.Parcel in) { + return new restartFile_result(in); + } + }; - 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("getPackageData_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("e:"); - if (this.e == null) { - sb.append("null"); - } else { - sb.append(this.e); - } - first = false; - sb.append(")"); - return sb.toString(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static class getPackageData_resultStandardSchemeFactory implements SchemeFactory { - public getPackageData_resultStandardScheme getScheme() { - return new getPackageData_resultStandardScheme(); - } - } + /** + * 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; + } - private static class getPackageData_resultStandardScheme extends StandardScheme<getPackageData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageData_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 PackageData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 1: // E - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(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, getPackageData_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.e != null) { - oprot.writeFieldBegin(E_FIELD_DESC); - struct.e.write(oprot); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * 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; - private static class getPackageData_resultTupleSchemeFactory implements SchemeFactory { - public getPackageData_resultTupleScheme getScheme() { - return new getPackageData_resultTupleScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class getPackageData_resultTupleScheme extends TupleScheme<getPackageData_result> { + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - if (struct.isSetE()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + public String getFieldName() { + return _fieldName; + } } - if (struct.isSetE()) { - struct.e.write(oprot); + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFile_result.class, metaDataMap); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.success = new PackageData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + public restartFile_result() { } - if (incoming.get(1)) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(true); + + /** + * Performs a deep copy on <i>other</i>. + */ + public restartFile_result(restartFile_result other) { } - } - } - } + public restartFile_result deepCopy() { + return new restartFile_result(this); + } - public static class getPackageInfo_args implements org.apache.thrift.TBase<getPackageInfo_args, getPackageInfo_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageInfo_args"); + @Override + public void clear() { + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageInfo_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageInfo_argsTupleSchemeFactory()); - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + /** 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(); + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageInfo_args.class, metaDataMap); - } + switch (field) { + } + throw new IllegalStateException(); + } - public getPackageInfo_args() { - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartFile_result) + return this.equals((restartFile_result) that); + return false; + } - public getPackageInfo_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + public boolean equals(restartFile_result that) { + if (that == null) + return false; - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageInfo_args(getPackageInfo_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + return true; + } - public getPackageInfo_args deepCopy() { - return new getPackageInfo_args(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + return list.hashCode(); + } - public int getPid() { - return this.pid; - } + @Override + public int compareTo(restartFile_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getPackageInfo_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + int lastComparison = 0; - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + return 0; + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartFile_result("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + sb.append(")"); + return sb.toString(); + } - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageInfo_args) - return this.equals((getPackageInfo_args)that); - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(getPackageInfo_args that) { - if (that == null) - return false; + private static class restartFile_resultStandardSchemeFactory implements SchemeFactory { + public restartFile_resultStandardScheme getScheme() { + return new restartFile_resultStandardScheme(); + } + } - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + private static class restartFile_resultStandardScheme extends StandardScheme<restartFile_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, restartFile_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(getPackageInfo_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageInfo_args typedOther = (getPackageInfo_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartFile_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class restartFile_resultTupleSchemeFactory implements SchemeFactory { + public restartFile_resultTupleScheme getScheme() { + return new restartFile_resultTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getPackageInfo_args("); - boolean first = true; + private static class restartFile_resultTupleScheme extends TupleScheme<restartFile_result> { - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartFile_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartFile_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public static class recheckPackage_args implements org.apache.thrift.TBase<recheckPackage_args, recheckPackage_args._Fields>, java.io.Serializable, Cloneable, Comparable<recheckPackage_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("recheckPackage_args"); - private static class getPackageInfo_argsStandardSchemeFactory implements SchemeFactory { - public getPackageInfo_argsStandardScheme getScheme() { - return new getPackageInfo_argsStandardScheme(); - } - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); - private static class getPackageInfo_argsStandardScheme extends StandardScheme<getPackageInfo_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageInfo_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, getPackageInfo_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - } + static { + schemes.put(StandardScheme.class, new recheckPackage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new recheckPackage_argsTupleSchemeFactory()); + } - private static class getPackageInfo_argsTupleSchemeFactory implements SchemeFactory { - public getPackageInfo_argsTupleScheme getScheme() { - return new getPackageInfo_argsTupleScheme(); - } - } + public int pid; // required - private static class getPackageInfo_argsTupleScheme extends TupleScheme<getPackageInfo_args> { + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); + out.writeInt(pid); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + @Override + public int describeContents() { + return 0; } - } - } - - } - public static class getPackageInfo_result implements org.apache.thrift.TBase<getPackageInfo_result, getPackageInfo_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageInfo_result"); + public recheckPackage_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - 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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short)1); + this.pid = in.readInt(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageInfo_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageInfo_resultTupleSchemeFactory()); - } + public static final android.os.Parcelable.Creator<recheckPackage_args> CREATOR = new android.os.Parcelable.Creator<recheckPackage_args>() { + @Override + public recheckPackage_args[] newArray(int size) { + return new recheckPackage_args[size]; + } - public PackageData success; // required - public PackageDoesNotExists e; // 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"), - E((short)1, "e"); - - 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 0: // SUCCESS - return SUCCESS; - case 1: // E - return E; - 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; - } - } + @Override + public recheckPackage_args createFromParcel(android.os.Parcel in) { + return new recheckPackage_args(in); + } + }; - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class))); - tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageInfo_result.class, metaDataMap); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"); - public getPackageInfo_result() { - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public getPackageInfo_result( - PackageData success, - PackageDoesNotExists e) - { - this(); - this.success = success; - this.e = e; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageInfo_result(getPackageInfo_result other) { - if (other.isSetSuccess()) { - this.success = new PackageData(other.success); - } - if (other.isSetE()) { - this.e = new PackageDoesNotExists(other.e); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + default: + return null; + } + } - public getPackageInfo_result deepCopy() { - return new getPackageInfo_result(this); - } + /** + * 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; + } - @Override - public void clear() { - this.success = null; - this.e = null; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public PackageData getSuccess() { - return this.success; - } + private final short _thriftId; + private final String _fieldName; - public getPackageInfo_result setSuccess(PackageData success) { - this.success = success; - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetSuccess() { - this.success = null; - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public String getFieldName() { + return _fieldName; + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public PackageDoesNotExists getE() { - return this.e; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(recheckPackage_args.class, metaDataMap); + } - public getPackageInfo_result setE(PackageDoesNotExists e) { - this.e = e; - return this; - } + public recheckPackage_args() { + } - public void unsetE() { - this.e = null; - } + public recheckPackage_args( + int pid) { + this(); + this.pid = pid; + setPidIsSet(true); + } - /** Returns true if field e is set (has been assigned a value) and false otherwise */ - public boolean isSetE() { - return this.e != null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public recheckPackage_args(recheckPackage_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + } - public void setEIsSet(boolean value) { - if (!value) { - this.e = null; - } - } + public recheckPackage_args deepCopy() { + return new recheckPackage_args(this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((PackageData)value); + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; } - break; - case E: - if (value == null) { - unsetE(); - } else { - setE((PackageDoesNotExists)value); + public int getPid() { + return this.pid; } - break; - } - } + public recheckPackage_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - case E: - return getE(); + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - } - throw new IllegalStateException(); - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - case E: - return isSetE(); - } - throw new IllegalStateException(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageInfo_result) - return this.equals((getPackageInfo_result)that); - return false; - } + } + } - public boolean equals(getPackageInfo_result that) { - if (that == null) - return false; - - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } - - boolean this_present_e = true && this.isSetE(); - boolean that_present_e = true && that.isSetE(); - if (this_present_e || that_present_e) { - if (!(this_present_e && that_present_e)) - return false; - if (!this.e.equals(that.e)) - return false; - } - - return true; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - @Override - public int hashCode() { - return 0; - } + } + throw new IllegalStateException(); + } - public int compareTo(getPackageInfo_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageInfo_result typedOther = (getPackageInfo_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetE()).compareTo(typedOther.isSetE()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetE()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, typedOther.e); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** 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(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + switch (field) { + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof recheckPackage_args) + return this.equals((recheckPackage_args) that); + return false; + } - 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("getPackageInfo_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("e:"); - if (this.e == null) { - sb.append("null"); - } else { - sb.append(this.e); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public boolean equals(recheckPackage_args that) { + if (that == null) + return false; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return true; + } - 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.getMessage()); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class getPackageInfo_resultStandardSchemeFactory implements SchemeFactory { - public getPackageInfo_resultStandardScheme getScheme() { - return new getPackageInfo_resultStandardScheme(); - } - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - private static class getPackageInfo_resultStandardScheme extends StandardScheme<getPackageInfo_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageInfo_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 PackageData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 1: // E - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(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, getPackageInfo_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.e != null) { - oprot.writeFieldBegin(E_FIELD_DESC); - struct.e.write(oprot); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return list.hashCode(); + } - } + @Override + public int compareTo(recheckPackage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class getPackageInfo_resultTupleSchemeFactory implements SchemeFactory { - public getPackageInfo_resultTupleScheme getScheme() { - return new getPackageInfo_resultTupleScheme(); - } - } + int lastComparison = 0; - private static class getPackageInfo_resultTupleScheme extends TupleScheme<getPackageInfo_result> { + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - if (struct.isSetE()) { - optionals.set(1); + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - oprot.writeBitSet(optionals, 2); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - if (struct.isSetE()) { - struct.e.write(oprot); + + @Override + public String toString() { + StringBuilder sb = new StringBuilder("recheckPackage_args("); + boolean first = true; + + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageInfo_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.success = new PackageData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - if (incoming.get(1)) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(true); + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - } - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public static class getFileData_args implements org.apache.thrift.TBase<getFileData_args, getFileData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileData_args"); + private static class recheckPackage_argsStandardSchemeFactory implements SchemeFactory { + public recheckPackage_argsStandardScheme getScheme() { + return new recheckPackage_argsStandardScheme(); + } + } - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); + private static class recheckPackage_argsStandardScheme extends StandardScheme<recheckPackage_args> { - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getFileData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getFileData_argsTupleSchemeFactory()); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, recheckPackage_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - public int fid; // 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 { - FID((short)1, "fid"); - - 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: // FID - return FID; - 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; - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileData_args.class, metaDataMap); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, recheckPackage_args struct) throws org.apache.thrift.TException { + struct.validate(); - public getFileData_args() { - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public getFileData_args( - int fid) - { - this(); - this.fid = fid; - setFidIsSet(true); - } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getFileData_args(getFileData_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - } + private static class recheckPackage_argsTupleSchemeFactory implements SchemeFactory { + public recheckPackage_argsTupleScheme getScheme() { + return new recheckPackage_argsTupleScheme(); + } + } - public getFileData_args deepCopy() { - return new getFileData_args(this); - } + private static class recheckPackage_argsTupleScheme extends TupleScheme<recheckPackage_args> { - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, recheckPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - public int getFid() { - return this.fid; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, recheckPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - public getFileData_args setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; } - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } + public static class recheckPackage_result implements org.apache.thrift.TBase<recheckPackage_result, recheckPackage_result._Fields>, java.io.Serializable, Cloneable, Comparable<recheckPackage_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("recheckPackage_result"); - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); + static { + schemes.put(StandardScheme.class, new recheckPackage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new recheckPackage_resultTupleSchemeFactory()); } - break; - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - } - throw new IllegalStateException(); - } + @Override + public int describeContents() { + return 0; + } - /** 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 FID: - return isSetFid(); - } - throw new IllegalStateException(); - } + public recheckPackage_result(android.os.Parcel in) { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getFileData_args) - return this.equals((getFileData_args)that); - return false; - } + public static final android.os.Parcelable.Creator<recheckPackage_result> CREATOR = new android.os.Parcelable.Creator<recheckPackage_result>() { + @Override + public recheckPackage_result[] newArray(int size) { + return new recheckPackage_result[size]; + } - public boolean equals(getFileData_args that) { - if (that == null) - return false; + @Override + public recheckPackage_result createFromParcel(android.os.Parcel in) { + return new recheckPackage_result(in); + } + }; - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - return true; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public int hashCode() { - return 0; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int compareTo(getFileData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getFileData_args typedOther = (getFileData_args)other; - - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** + * 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; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + private final short _thriftId; + private final String _fieldName; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getFileData_args("); - boolean first = true; + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - sb.append("fid:"); - sb.append(this.fid); - first = false; - sb.append(")"); - return sb.toString(); - } + public short getThriftFieldId() { + return _thriftId; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public String getFieldName() { + return _fieldName; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(recheckPackage_result.class, metaDataMap); + } - private static class getFileData_argsStandardSchemeFactory implements SchemeFactory { - public getFileData_argsStandardScheme getScheme() { - return new getFileData_argsStandardScheme(); - } - } + public recheckPackage_result() { + } - private static class getFileData_argsStandardScheme extends StandardScheme<getFileData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getFileData_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: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(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, getFileData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public recheckPackage_result(recheckPackage_result other) { + } - } + public recheckPackage_result deepCopy() { + return new recheckPackage_result(this); + } - private static class getFileData_argsTupleSchemeFactory implements SchemeFactory { - public getFileData_argsTupleScheme getScheme() { - return new getFileData_argsTupleScheme(); - } - } + @Override + public void clear() { + } - private static class getFileData_argsTupleScheme extends TupleScheme<getFileData_args> { + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getFileData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); + + /** 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) { + } + throw new IllegalStateException(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getFileData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof recheckPackage_result) + return this.equals((recheckPackage_result) that); + return false; } - } - } - } + public boolean equals(recheckPackage_result that) { + if (that == null) + return false; - public static class getFileData_result implements org.apache.thrift.TBase<getFileData_result, getFileData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileData_result"); + return true; + } - 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 E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short)1); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getFileData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getFileData_resultTupleSchemeFactory()); - } + return list.hashCode(); + } - public FileData success; // required - public FileDoesNotExists e; // 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"), - E((short)1, "e"); - - 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 0: // SUCCESS - return SUCCESS; - case 1: // E - return E; - 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; - } - } + @Override + public int compareTo(recheckPackage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, FileData.class))); - tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileData_result.class, metaDataMap); - } + int lastComparison = 0; - public getFileData_result() { - } + return 0; + } - public getFileData_result( - FileData success, - FileDoesNotExists e) - { - this(); - this.success = success; - this.e = e; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getFileData_result(getFileData_result other) { - if (other.isSetSuccess()) { - this.success = new FileData(other.success); - } - if (other.isSetE()) { - this.e = new FileDoesNotExists(other.e); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public getFileData_result deepCopy() { - return new getFileData_result(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 void clear() { - this.success = null; - this.e = null; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("recheckPackage_result("); + boolean first = true; - public FileData getSuccess() { - return this.success; - } + sb.append(")"); + return sb.toString(); + } - public getFileData_result setSuccess(FileData success) { - this.success = success; - return this; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void unsetSuccess() { - this.success = null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + private static class recheckPackage_resultStandardSchemeFactory implements SchemeFactory { + public recheckPackage_resultStandardScheme getScheme() { + return new recheckPackage_resultStandardScheme(); + } + } - public FileDoesNotExists getE() { - return this.e; - } + private static class recheckPackage_resultStandardScheme extends StandardScheme<recheckPackage_result> { - public getFileData_result setE(FileDoesNotExists e) { - this.e = e; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, recheckPackage_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public void unsetE() { - this.e = null; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field e is set (has been assigned a value) and false otherwise */ - public boolean isSetE() { - return this.e != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, recheckPackage_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void setEIsSet(boolean value) { - if (!value) { - this.e = null; - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((FileData)value); } - break; - case E: - if (value == null) { - unsetE(); - } else { - setE((FileDoesNotExists)value); + private static class recheckPackage_resultTupleSchemeFactory implements SchemeFactory { + public recheckPackage_resultTupleScheme getScheme() { + return new recheckPackage_resultTupleScheme(); + } } - break; - } - } + private static class recheckPackage_resultTupleScheme extends TupleScheme<recheckPackage_result> { - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, recheckPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - case E: - return getE(); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, recheckPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - } - throw new IllegalStateException(); } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - case E: - return isSetE(); - } - throw new IllegalStateException(); - } + public static class stopAllDownloads_args implements org.apache.thrift.TBase<stopAllDownloads_args, stopAllDownloads_args._Fields>, java.io.Serializable, Cloneable, Comparable<stopAllDownloads_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopAllDownloads_args"); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getFileData_result) - return this.equals((getFileData_result)that); - return false; - } - public boolean equals(getFileData_result that) { - if (that == null) - return false; - - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } - - boolean this_present_e = true && this.isSetE(); - boolean that_present_e = true && that.isSetE(); - if (this_present_e || that_present_e) { - if (!(this_present_e && that_present_e)) - return false; - if (!this.e.equals(that.e)) - return false; - } - - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new stopAllDownloads_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new stopAllDownloads_argsTupleSchemeFactory()); + } - public int compareTo(getFileData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getFileData_result typedOther = (getFileData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetE()).compareTo(typedOther.isSetE()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetE()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, typedOther.e); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int describeContents() { + return 0; + } - 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("getFileData_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("e:"); - if (this.e == null) { - sb.append("null"); - } else { - sb.append(this.e); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public stopAllDownloads_args(android.os.Parcel in) { + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public static final android.os.Parcelable.Creator<stopAllDownloads_args> CREATOR = new android.os.Parcelable.Creator<stopAllDownloads_args>() { + @Override + public stopAllDownloads_args[] newArray(int size) { + return new stopAllDownloads_args[size]; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public stopAllDownloads_args createFromParcel(android.os.Parcel in) { + return new stopAllDownloads_args(in); + } + }; - 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.getMessage()); - } - } + /** 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 class getFileData_resultStandardSchemeFactory implements SchemeFactory { - public getFileData_resultStandardScheme getScheme() { - return new getFileData_resultStandardScheme(); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class getFileData_resultStandardScheme extends StandardScheme<getFileData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getFileData_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 FileData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 1: // E - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.e = new FileDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(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, getFileData_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.e != null) { - oprot.writeFieldBegin(E_FIELD_DESC); - struct.e.write(oprot); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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) { + default: + return null; + } + } - private static class getFileData_resultTupleSchemeFactory implements SchemeFactory { - public getFileData_resultTupleScheme getScheme() { - return new getFileData_resultTupleScheme(); - } - } + /** + * 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 static class getFileData_resultTupleScheme extends TupleScheme<getFileData_result> { + private final short _thriftId; + private final String _fieldName; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getFileData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - if (struct.isSetE()) { - optionals.set(1); + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } } - oprot.writeBitSet(optionals, 2); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopAllDownloads_args.class, metaDataMap); } - if (struct.isSetE()) { - struct.e.write(oprot); + + public stopAllDownloads_args() { } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getFileData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.success = new FileData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + /** + * Performs a deep copy on <i>other</i>. + */ + public stopAllDownloads_args(stopAllDownloads_args other) { } - if (incoming.get(1)) { - struct.e = new FileDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(true); + + public stopAllDownloads_args deepCopy() { + return new stopAllDownloads_args(this); } - } - } - } + @Override + public void clear() { + } - public static class getQueue_args implements org.apache.thrift.TBase<getQueue_args, getQueue_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueue_args"); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getQueue_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getQueue_argsTupleSchemeFactory()); - } + /** 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) { + } + throw new IllegalStateException(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueue_args.class, metaDataMap); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof stopAllDownloads_args) + return this.equals((stopAllDownloads_args) that); + return false; + } - public getQueue_args() { - } + public boolean equals(stopAllDownloads_args that) { + if (that == null) + return false; - /** - * Performs a deep copy on <i>other</i>. - */ - public getQueue_args(getQueue_args other) { - } + return true; + } - public getQueue_args deepCopy() { - return new getQueue_args(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - } + return list.hashCode(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int compareTo(stopAllDownloads_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + int lastComparison = 0; - /** 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(); - } + return 0; + } - switch (field) { - } - throw new IllegalStateException(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getQueue_args) - return this.equals((getQueue_args)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public boolean equals(getQueue_args that) { - if (that == null) - return false; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - return true; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("stopAllDownloads_args("); + boolean first = true; - @Override - public int hashCode() { - return 0; - } + sb.append(")"); + return sb.toString(); + } - public int compareTo(getQueue_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - int lastComparison = 0; - getQueue_args typedOther = (getQueue_args)other; + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - return 0; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class stopAllDownloads_argsStandardSchemeFactory implements SchemeFactory { + public stopAllDownloads_argsStandardScheme getScheme() { + return new stopAllDownloads_argsStandardScheme(); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class stopAllDownloads_argsStandardScheme extends StandardScheme<stopAllDownloads_args> { - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, stopAllDownloads_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(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getQueue_args("); - boolean first = true; + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - sb.append(")"); - return sb.toString(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, stopAllDownloads_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + } - 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.getMessage()); - } - } + private static class stopAllDownloads_argsTupleSchemeFactory implements SchemeFactory { + public stopAllDownloads_argsTupleScheme getScheme() { + return new stopAllDownloads_argsTupleScheme(); + } + } - private static class getQueue_argsStandardSchemeFactory implements SchemeFactory { - public getQueue_argsStandardScheme getScheme() { - return new getQueue_argsStandardScheme(); - } - } + private static class stopAllDownloads_argsTupleScheme extends TupleScheme<stopAllDownloads_args> { - private static class getQueue_argsStandardScheme extends StandardScheme<getQueue_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getQueue_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, getQueue_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static class getQueue_argsTupleSchemeFactory implements SchemeFactory { - public getQueue_argsTupleScheme getScheme() { - return new getQueue_argsTupleScheme(); - } } - private static class getQueue_argsTupleScheme extends TupleScheme<getQueue_args> { + public static class stopAllDownloads_result implements org.apache.thrift.TBase<stopAllDownloads_result, stopAllDownloads_result._Fields>, java.io.Serializable, Cloneable, Comparable<stopAllDownloads_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopAllDownloads_result"); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } - - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public static class getQueue_result implements org.apache.thrift.TBase<getQueue_result, getQueue_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueue_result"); + static { + schemes.put(StandardScheme.class, new stopAllDownloads_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new stopAllDownloads_resultTupleSchemeFactory()); + } - 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getQueue_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getQueue_resultTupleSchemeFactory()); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public List<PackageData> 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 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 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 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; - } - } + @Override + public int describeContents() { + return 0; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueue_result.class, metaDataMap); - } + public stopAllDownloads_result(android.os.Parcel in) { + } - public getQueue_result() { - } + public static final android.os.Parcelable.Creator<stopAllDownloads_result> CREATOR = new android.os.Parcelable.Creator<stopAllDownloads_result>() { + @Override + public stopAllDownloads_result[] newArray(int size) { + return new stopAllDownloads_result[size]; + } - public getQueue_result( - List<PackageData> success) - { - this(); - this.success = success; - } + @Override + public stopAllDownloads_result createFromParcel(android.os.Parcel in) { + return new stopAllDownloads_result(in); + } + }; - /** - * Performs a deep copy on <i>other</i>. - */ - public getQueue_result(getQueue_result other) { - if (other.isSetSuccess()) { - List<PackageData> __this__success = new ArrayList<PackageData>(); - for (PackageData other_element : other.success) { - __this__success.add(new PackageData(other_element)); - } - this.success = __this__success; - } - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public getQueue_result deepCopy() { - return new getQueue_result(this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public void clear() { - this.success = null; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public java.util.Iterator<PackageData> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + /** + * 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; + } - public void addToSuccess(PackageData elem) { - if (this.success == null) { - this.success = new ArrayList<PackageData>(); - } - this.success.add(elem); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public List<PackageData> getSuccess() { - return this.success; - } + private final short _thriftId; + private final String _fieldName; - public getQueue_result setSuccess(List<PackageData> success) { - this.success = success; - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetSuccess() { - this.success = null; - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public String getFieldName() { + return _fieldName; + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<PackageData>)value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopAllDownloads_result.class, metaDataMap); } - break; - } - } + public stopAllDownloads_result() { + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + /** + * Performs a deep copy on <i>other</i>. + */ + public stopAllDownloads_result(stopAllDownloads_result other) { + } - } - throw new IllegalStateException(); - } + public stopAllDownloads_result deepCopy() { + return new stopAllDownloads_result(this); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + @Override + public void clear() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getQueue_result) - return this.equals((getQueue_result)that); - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public boolean equals(getQueue_result that) { - if (that == null) - return false; + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - 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; - } + /** 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(); + } - return true; - } + switch (field) { + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof stopAllDownloads_result) + return this.equals((stopAllDownloads_result) that); + return false; + } - public int compareTo(getQueue_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getQueue_result typedOther = (getQueue_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public boolean equals(stopAllDownloads_result that) { + if (that == null) + return false; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + return true; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - 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("getQueue_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(); - } + return list.hashCode(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int compareTo(stopAllDownloads_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + int lastComparison = 0; - 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.getMessage()); - } - } + return 0; + } - private static class getQueue_resultStandardSchemeFactory implements SchemeFactory { - public getQueue_resultStandardScheme getScheme() { - return new getQueue_resultStandardScheme(); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class getQueue_resultStandardScheme extends StandardScheme<getQueue_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getQueue_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 _list182 = iprot.readListBegin(); - struct.success = new ArrayList<PackageData>(_list182.size); - for (int _i183 = 0; _i183 < _list182.size; ++_i183) - { - PackageData _elem184; // required - _elem184 = new PackageData(); - _elem184.read(iprot); - struct.success.add(_elem184); - } - iprot.readListEnd(); - } - 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, getQueue_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 (PackageData _iter185 : struct.success) - { - _iter185.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class getQueue_resultTupleSchemeFactory implements SchemeFactory { - public getQueue_resultTupleScheme getScheme() { - return new getQueue_resultTupleScheme(); - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("stopAllDownloads_result("); + boolean first = true; - private static class getQueue_resultTupleScheme extends TupleScheme<getQueue_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (PackageData _iter186 : struct.success) - { - _iter186.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list187 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<PackageData>(_list187.size); - for (int _i188 = 0; _i188 < _list187.size; ++_i188) - { - PackageData _elem189; // required - _elem189 = new PackageData(); - _elem189.read(iprot); - struct.success.add(_elem189); - } - } - struct.setSuccessIsSet(true); - } - } - } + sb.append(")"); + return sb.toString(); + } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public static class getCollector_args implements org.apache.thrift.TBase<getCollector_args, getCollector_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollector_args"); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(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 final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCollector_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCollector_argsTupleSchemeFactory()); - } + private static class stopAllDownloads_resultStandardSchemeFactory implements SchemeFactory { + public stopAllDownloads_resultStandardScheme getScheme() { + return new stopAllDownloads_resultStandardScheme(); + } + } + private static class stopAllDownloads_resultStandardScheme extends StandardScheme<stopAllDownloads_result> { - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollector_args.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, stopAllDownloads_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public getCollector_args() { - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getCollector_args(getCollector_args other) { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, stopAllDownloads_result struct) throws org.apache.thrift.TException { + struct.validate(); - public getCollector_args deepCopy() { - return new getCollector_args(this); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void clear() { - } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class stopAllDownloads_resultTupleSchemeFactory implements SchemeFactory { + public stopAllDownloads_resultTupleScheme getScheme() { + return new stopAllDownloads_resultTupleScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static class stopAllDownloads_resultTupleScheme extends TupleScheme<stopAllDownloads_result> { - /** 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(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCollector_args) - return this.equals((getCollector_args)that); - return false; } - public boolean equals(getCollector_args that) { - if (that == null) - return false; + public static class stopDownloads_args implements org.apache.thrift.TBase<stopDownloads_args, stopDownloads_args._Fields>, java.io.Serializable, Cloneable, Comparable<stopDownloads_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopDownloads_args"); - return true; - } + private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short) 1); - @Override - public int hashCode() { - return 0; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public int compareTo(getCollector_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + static { + schemes.put(StandardScheme.class, new stopDownloads_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new stopDownloads_argsTupleSchemeFactory()); + } - int lastComparison = 0; - getCollector_args typedOther = (getCollector_args)other; + public List<Integer> fids; // required - return 0; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(fids); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public int describeContents() { + return 0; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public stopDownloads_args(android.os.Parcel in) { + this.fids = new ArrayList<Integer>(); + in.readList(this.fids, stopDownloads_args.class.getClassLoader()); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public static final android.os.Parcelable.Creator<stopDownloads_args> CREATOR = new android.os.Parcelable.Creator<stopDownloads_args>() { + @Override + public stopDownloads_args[] newArray(int size) { + return new stopDownloads_args[size]; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getCollector_args("); - boolean first = true; + @Override + public stopDownloads_args createFromParcel(android.os.Parcel in) { + return new stopDownloads_args(in); + } + }; - sb.append(")"); - return sb.toString(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FIDS((short) 1, "fids"); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FIDS + return FIDS; + default: + return null; + } + } - private static class getCollector_argsStandardSchemeFactory implements SchemeFactory { - public getCollector_argsStandardScheme getScheme() { - return new getCollector_argsStandardScheme(); - } - } + /** + * 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; + } - private static class getCollector_argsStandardScheme extends StandardScheme<getCollector_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCollector_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, getCollector_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * 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; - private static class getCollector_argsTupleSchemeFactory implements SchemeFactory { - public getCollector_argsTupleScheme getScheme() { - return new getCollector_argsTupleScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class getCollector_argsTupleScheme extends TupleScheme<getCollector_args> { + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCollector_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCollector_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32, "FileID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopDownloads_args.class, metaDataMap); + } - public static class getCollector_result implements org.apache.thrift.TBase<getCollector_result, getCollector_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollector_result"); + public stopDownloads_args() { + } - 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); + public stopDownloads_args( + List<Integer> fids) { + this(); + this.fids = fids; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCollector_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCollector_resultTupleSchemeFactory()); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public stopDownloads_args(stopDownloads_args other) { + if (other.isSetFids()) { + List<Integer> __this__fids = new ArrayList<Integer>(other.fids.size()); + for (Integer other_element : other.fids) { + __this__fids.add(other_element); + } + this.fids = __this__fids; + } + } - public List<PackageData> 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 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 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 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; - } - } + public stopDownloads_args deepCopy() { + return new stopDownloads_args(this); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollector_result.class, metaDataMap); - } + @Override + public void clear() { + this.fids = null; + } - public getCollector_result() { - } + public int getFidsSize() { + return (this.fids == null) ? 0 : this.fids.size(); + } - public getCollector_result( - List<PackageData> success) - { - this(); - this.success = success; - } + public java.util.Iterator<Integer> getFidsIterator() { + return (this.fids == null) ? null : this.fids.iterator(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getCollector_result(getCollector_result other) { - if (other.isSetSuccess()) { - List<PackageData> __this__success = new ArrayList<PackageData>(); - for (PackageData other_element : other.success) { - __this__success.add(new PackageData(other_element)); - } - this.success = __this__success; - } - } + public void addToFids(int elem) { + if (this.fids == null) { + this.fids = new ArrayList<Integer>(); + } + this.fids.add(elem); + } - public getCollector_result deepCopy() { - return new getCollector_result(this); - } + public List<Integer> getFids() { + return this.fids; + } - @Override - public void clear() { - this.success = null; - } + public stopDownloads_args setFids(List<Integer> fids) { + this.fids = fids; + return this; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public void unsetFids() { + this.fids = null; + } - public java.util.Iterator<PackageData> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + /** Returns true if field fids is set (has been assigned a value) and false otherwise */ + public boolean isSetFids() { + return this.fids != null; + } - public void addToSuccess(PackageData elem) { - if (this.success == null) { - this.success = new ArrayList<PackageData>(); - } - this.success.add(elem); - } + public void setFidsIsSet(boolean value) { + if (!value) { + this.fids = null; + } + } - public List<PackageData> getSuccess() { - return this.success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FIDS: + if (value == null) { + unsetFids(); + } else { + setFids((List<Integer>) value); + } + break; - public getCollector_result setSuccess(List<PackageData> success) { - this.success = success; - return this; - } + } + } - public void unsetSuccess() { - this.success = null; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FIDS: + return getFids(); - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + } + throw new IllegalStateException(); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<PackageData>)value); + switch (field) { + case FIDS: + return isSetFids(); + } + throw new IllegalStateException(); } - break; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof stopDownloads_args) + return this.equals((stopDownloads_args) that); + return false; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public boolean equals(stopDownloads_args that) { + if (that == null) + return false; - } - throw new IllegalStateException(); - } + boolean this_present_fids = true && this.isSetFids(); + boolean that_present_fids = true && that.isSetFids(); + if (this_present_fids || that_present_fids) { + if (!(this_present_fids && that_present_fids)) + return false; + if (!this.fids.equals(that.fids)) + return false; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + return true; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCollector_result) - return this.equals((getCollector_result)that); - return false; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public boolean equals(getCollector_result that) { - if (that == null) - return false; + boolean present_fids = true && (isSetFids()); + list.add(present_fids); + if (present_fids) + list.add(fids); - 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 list.hashCode(); + } - return true; - } + @Override + public int compareTo(stopDownloads_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public int hashCode() { - return 0; - } + int lastComparison = 0; - public int compareTo(getCollector_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCollector_result typedOther = (getCollector_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + lastComparison = Boolean.valueOf(isSetFids()).compareTo(other.isSetFids()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFids()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, other.fids); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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 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("getCollector_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 write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("stopDownloads_args("); + boolean first = true; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + sb.append("fids:"); + if (this.fids == null) { + sb.append("null"); + } else { + sb.append(this.fids); + } + first = false; + sb.append(")"); + return sb.toString(); + } - 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.getMessage()); - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static class getCollector_resultStandardSchemeFactory implements SchemeFactory { - public getCollector_resultStandardScheme getScheme() { - return new getCollector_resultStandardScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class getCollector_resultStandardScheme extends StandardScheme<getCollector_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCollector_result struct) throws org.apache.thrift.TException { - org.apache.thrift.protocol.TField schemeField; - iprot.readStructBegin(); - while (true) - { - schemeField = iprot.readFieldBegin(); - if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { - break; - } - switch (schemeField.id) { - case 0: // SUCCESS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list190 = iprot.readListBegin(); - struct.success = new ArrayList<PackageData>(_list190.size); - for (int _i191 = 0; _i191 < _list190.size; ++_i191) - { - PackageData _elem192; // required - _elem192 = new PackageData(); - _elem192.read(iprot); - struct.success.add(_elem192); - } - iprot.readListEnd(); - } - 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, getCollector_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 (PackageData _iter193 : struct.success) - { - _iter193.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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 stopDownloads_argsStandardSchemeFactory implements SchemeFactory { + public stopDownloads_argsStandardScheme getScheme() { + return new stopDownloads_argsStandardScheme(); + } + } - private static class getCollector_resultTupleSchemeFactory implements SchemeFactory { - public getCollector_resultTupleScheme getScheme() { - return new getCollector_resultTupleScheme(); - } - } + private static class stopDownloads_argsStandardScheme extends StandardScheme<stopDownloads_args> { - private static class getCollector_resultTupleScheme extends TupleScheme<getCollector_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCollector_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (PackageData _iter194 : struct.success) - { - _iter194.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCollector_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list195 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<PackageData>(_list195.size); - for (int _i196 = 0; _i196 < _list195.size; ++_i196) - { - PackageData _elem197; // required - _elem197 = new PackageData(); - _elem197.read(iprot); - struct.success.add(_elem197); - } - } - struct.setSuccessIsSet(true); - } - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, stopDownloads_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: // FIDS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list306 = iprot.readListBegin(); + struct.fids = new ArrayList<Integer>(_list306.size); + int _elem307; + for (int _i308 = 0; _i308 < _list306.size; ++_i308) { + _elem307 = iprot.readI32(); + struct.fids.add(_elem307); + } + iprot.readListEnd(); + } + struct.setFidsIsSet(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 static class getQueueData_args implements org.apache.thrift.TBase<getQueueData_args, getQueueData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueueData_args"); + public void write(org.apache.thrift.protocol.TProtocol oprot, stopDownloads_args struct) throws org.apache.thrift.TException { + struct.validate(); + oprot.writeStructBegin(STRUCT_DESC); + if (struct.fids != null) { + oprot.writeFieldBegin(FIDS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); + for (int _iter309 : struct.fids) { + oprot.writeI32(_iter309); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getQueueData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getQueueData_argsTupleSchemeFactory()); - } + } + private static class stopDownloads_argsTupleSchemeFactory implements SchemeFactory { + public stopDownloads_argsTupleScheme getScheme() { + return new stopDownloads_argsTupleScheme(); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueueData_args.class, metaDataMap); - } + private static class stopDownloads_argsTupleScheme extends TupleScheme<stopDownloads_args> { - public getQueueData_args() { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, stopDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFids()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetFids()) { + { + oprot.writeI32(struct.fids.size()); + for (int _iter310 : struct.fids) { + oprot.writeI32(_iter310); + } + } + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getQueueData_args(getQueueData_args other) { - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, stopDownloads_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list311 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.fids = new ArrayList<Integer>(_list311.size); + int _elem312; + for (int _i313 = 0; _i313 < _list311.size; ++_i313) { + _elem312 = iprot.readI32(); + struct.fids.add(_elem312); + } + } + struct.setFidsIsSet(true); + } + } + } - public getQueueData_args deepCopy() { - return new getQueueData_args(this); } - @Override - public void clear() { - } + public static class stopDownloads_result implements org.apache.thrift.TBase<stopDownloads_result, stopDownloads_result._Fields>, java.io.Serializable, Cloneable, Comparable<stopDownloads_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopDownloads_result"); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** 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(); - } + static { + schemes.put(StandardScheme.class, new stopDownloads_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new stopDownloads_resultTupleSchemeFactory()); + } - switch (field) { - } - throw new IllegalStateException(); - } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getQueueData_args) - return this.equals((getQueueData_args)that); - return false; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public boolean equals(getQueueData_args that) { - if (that == null) - return false; + @Override + public int describeContents() { + return 0; + } - return true; - } + public stopDownloads_result(android.os.Parcel in) { + } - @Override - public int hashCode() { - return 0; - } + public static final android.os.Parcelable.Creator<stopDownloads_result> CREATOR = new android.os.Parcelable.Creator<stopDownloads_result>() { + @Override + public stopDownloads_result[] newArray(int size) { + return new stopDownloads_result[size]; + } - public int compareTo(getQueueData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public stopDownloads_result createFromParcel(android.os.Parcel in) { + return new stopDownloads_result(in); + } + }; - int lastComparison = 0; - getQueueData_args typedOther = (getQueueData_args)other; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - return 0; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** + * 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; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getQueueData_args("); - boolean first = true; + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - sb.append(")"); - return sb.toString(); - } + private final short _thriftId; + private final String _fieldName; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public short getThriftFieldId() { + return _thriftId; + } - 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.getMessage()); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class getQueueData_argsStandardSchemeFactory implements SchemeFactory { - public getQueueData_argsStandardScheme getScheme() { - return new getQueueData_argsStandardScheme(); - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class getQueueData_argsStandardScheme extends StandardScheme<getQueueData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getQueueData_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, getQueueData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopDownloads_result.class, metaDataMap); + } - } + public stopDownloads_result() { + } - private static class getQueueData_argsTupleSchemeFactory implements SchemeFactory { - public getQueueData_argsTupleScheme getScheme() { - return new getQueueData_argsTupleScheme(); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public stopDownloads_result(stopDownloads_result other) { + } - private static class getQueueData_argsTupleScheme extends TupleScheme<getQueueData_args> { + public stopDownloads_result deepCopy() { + return new stopDownloads_result(this); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getQueueData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void clear() { + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getQueueData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public static class getQueueData_result implements org.apache.thrift.TBase<getQueueData_result, getQueueData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getQueueData_result"); + /** 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(); + } - 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); + switch (field) { + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getQueueData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getQueueData_resultTupleSchemeFactory()); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof stopDownloads_result) + return this.equals((stopDownloads_result) that); + return false; + } - public List<PackageData> 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 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 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 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; - } - } + public boolean equals(stopDownloads_result that) { + if (that == null) + return false; - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getQueueData_result.class, metaDataMap); - } + return true; + } - public getQueueData_result() { - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public getQueueData_result( - List<PackageData> success) - { - this(); - this.success = success; - } + return list.hashCode(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getQueueData_result(getQueueData_result other) { - if (other.isSetSuccess()) { - List<PackageData> __this__success = new ArrayList<PackageData>(); - for (PackageData other_element : other.success) { - __this__success.add(new PackageData(other_element)); - } - this.success = __this__success; - } - } + @Override + public int compareTo(stopDownloads_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getQueueData_result deepCopy() { - return new getQueueData_result(this); - } + int lastComparison = 0; - @Override - public void clear() { - this.success = null; - } + return 0; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public java.util.Iterator<PackageData> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void addToSuccess(PackageData elem) { - if (this.success == null) { - this.success = new ArrayList<PackageData>(); - } - this.success.add(elem); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public List<PackageData> getSuccess() { - return this.success; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("stopDownloads_result("); + boolean first = true; - public getQueueData_result setSuccess(List<PackageData> success) { - this.success = success; - return this; - } + sb.append(")"); + return sb.toString(); + } - public void unsetSuccess() { - this.success = null; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<PackageData>)value); + private static class stopDownloads_resultStandardSchemeFactory implements SchemeFactory { + public stopDownloads_resultStandardScheme getScheme() { + return new stopDownloads_resultStandardScheme(); + } } - break; - } - } + private static class stopDownloads_resultStandardScheme extends StandardScheme<stopDownloads_result> { - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void read(org.apache.thrift.protocol.TProtocol iprot, stopDownloads_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, stopDownloads_result struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getQueueData_result) - return this.equals((getQueueData_result)that); - return false; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class stopDownloads_resultTupleSchemeFactory implements SchemeFactory { + public stopDownloads_resultTupleScheme getScheme() { + return new stopDownloads_resultTupleScheme(); + } + } - public boolean equals(getQueueData_result that) { - if (that == null) - return false; + private static class stopDownloads_resultTupleScheme extends TupleScheme<stopDownloads_result> { - 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; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, stopDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - return true; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, stopDownloads_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - @Override - public int hashCode() { - return 0; } - public int compareTo(getQueueData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getQueueData_result typedOther = (getQueueData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public static class setPackageName_args implements org.apache.thrift.TBase<setPackageName_args, setPackageName_args._Fields>, java.io.Serializable, Cloneable, Comparable<setPackageName_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageName_args"); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short) 2); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - 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("getQueueData_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(); - } + static { + schemes.put(StandardScheme.class, new setPackageName_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setPackageName_argsTupleSchemeFactory()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public int pid; // required + public String name; // required - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - 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.getMessage()); - } - } + out.writeInt(pid); + out.writeString(name); + } - private static class getQueueData_resultStandardSchemeFactory implements SchemeFactory { - public getQueueData_resultStandardScheme getScheme() { - return new getQueueData_resultStandardScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class getQueueData_resultStandardScheme extends StandardScheme<getQueueData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getQueueData_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 ArrayList<PackageData>(_list198.size); - for (int _i199 = 0; _i199 < _list198.size; ++_i199) - { - PackageData _elem200; // required - _elem200 = new PackageData(); - _elem200.read(iprot); - struct.success.add(_elem200); - } - iprot.readListEnd(); - } - 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, getQueueData_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 (PackageData _iter201 : struct.success) - { - _iter201.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public setPackageName_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - } + this.pid = in.readInt(); + this.name = in.readString(); + } - private static class getQueueData_resultTupleSchemeFactory implements SchemeFactory { - public getQueueData_resultTupleScheme getScheme() { - return new getQueueData_resultTupleScheme(); - } - } + public static final android.os.Parcelable.Creator<setPackageName_args> CREATOR = new android.os.Parcelable.Creator<setPackageName_args>() { + @Override + public setPackageName_args[] newArray(int size) { + return new setPackageName_args[size]; + } - private static class getQueueData_resultTupleScheme extends TupleScheme<getQueueData_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getQueueData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (PackageData _iter202 : struct.success) - { - _iter202.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getQueueData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list203 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<PackageData>(_list203.size); - for (int _i204 = 0; _i204 < _list203.size; ++_i204) - { - PackageData _elem205; // required - _elem205 = new PackageData(); - _elem205.read(iprot); - struct.success.add(_elem205); - } - } - struct.setSuccessIsSet(true); - } - } - } + @Override + public setPackageName_args createFromParcel(android.os.Parcel in) { + return new setPackageName_args(in); + } + }; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"), + NAME((short) 2, "name"); - public static class getCollectorData_args implements org.apache.thrift.TBase<getCollectorData_args, getCollectorData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollectorData_args"); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCollectorData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCollectorData_argsTupleSchemeFactory()); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + case 2: // 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollectorData_args.class, metaDataMap); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public getCollectorData_args() { - } + private final short _thriftId; + private final String _fieldName; - /** - * Performs a deep copy on <i>other</i>. - */ - public getCollectorData_args(getCollectorData_args other) { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public getCollectorData_args deepCopy() { - return new getCollectorData_args(this); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void clear() { - } + public String getFieldName() { + return _fieldName; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + 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))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageName_args.class, metaDataMap); + } - /** 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(); - } + public setPackageName_args() { + } - switch (field) { - } - throw new IllegalStateException(); - } + public setPackageName_args( + int pid, + String name) { + this(); + this.pid = pid; + setPidIsSet(true); + this.name = name; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCollectorData_args) - return this.equals((getCollectorData_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public setPackageName_args(setPackageName_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + if (other.isSetName()) { + this.name = other.name; + } + } - public boolean equals(getCollectorData_args that) { - if (that == null) - return false; + public setPackageName_args deepCopy() { + return new setPackageName_args(this); + } - return true; - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + this.name = null; + } - @Override - public int hashCode() { - return 0; - } + public int getPid() { + return this.pid; + } - public int compareTo(getCollectorData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public setPackageName_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - int lastComparison = 0; - getCollectorData_args typedOther = (getCollectorData_args)other; + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - return 0; - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public String getName() { + return this.name; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public setPackageName_args setName(String name) { + this.name = name; + return this; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getCollectorData_args("); - boolean first = true; + public void unsetName() { + this.name = null; + } - sb.append(")"); - return sb.toString(); - } + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - 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.getMessage()); - } - } + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; - private static class getCollectorData_argsStandardSchemeFactory implements SchemeFactory { - public getCollectorData_argsStandardScheme getScheme() { - return new getCollectorData_argsStandardScheme(); - } - } + } + } - private static class getCollectorData_argsStandardScheme extends StandardScheme<getCollectorData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCollectorData_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, getCollectorData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - } + case NAME: + return getName(); - private static class getCollectorData_argsTupleSchemeFactory implements SchemeFactory { - public getCollectorData_argsTupleScheme getScheme() { - return new getCollectorData_argsTupleScheme(); - } - } + } + throw new IllegalStateException(); + } - private static class getCollectorData_argsTupleScheme extends TupleScheme<getCollectorData_args> { + /** 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(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCollectorData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + switch (field) { + case PID: + return isSetPid(); + case NAME: + return isSetName(); + } + throw new IllegalStateException(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCollectorData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setPackageName_args) + return this.equals((setPackageName_args) that); + return false; + } - } + public boolean equals(setPackageName_args that) { + if (that == null) + return false; - public static class getCollectorData_result implements org.apache.thrift.TBase<getCollectorData_result, getCollectorData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCollectorData_result"); + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - 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); + 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; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCollectorData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCollectorData_resultTupleSchemeFactory()); - } + return true; + } - public List<PackageData> 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 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 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 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; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, PackageData.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCollectorData_result.class, metaDataMap); - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public getCollectorData_result() { - } + boolean present_name = true && (isSetName()); + list.add(present_name); + if (present_name) + list.add(name); - public getCollectorData_result( - List<PackageData> success) - { - this(); - this.success = success; - } + return list.hashCode(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getCollectorData_result(getCollectorData_result other) { - if (other.isSetSuccess()) { - List<PackageData> __this__success = new ArrayList<PackageData>(); - for (PackageData other_element : other.success) { - __this__success.add(new PackageData(other_element)); - } - this.success = __this__success; - } - } + @Override + public int compareTo(setPackageName_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getCollectorData_result deepCopy() { - return new getCollectorData_result(this); - } + int lastComparison = 0; - @Override - public void clear() { - this.success = null; - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + 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; + } + } + return 0; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public java.util.Iterator<PackageData> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void addToSuccess(PackageData elem) { - if (this.success == null) { - this.success = new ArrayList<PackageData>(); - } - this.success.add(elem); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public List<PackageData> getSuccess() { - return this.success; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("setPackageName_args("); + boolean first = true; - public getCollectorData_result setSuccess(List<PackageData> success) { - this.success = success; - return this; - } + sb.append("pid:"); + sb.append(this.pid); + first = false; + if (!first) sb.append(", "); + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public void unsetSuccess() { - this.success = null; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<PackageData>)value); + private static class setPackageName_argsStandardSchemeFactory implements SchemeFactory { + public setPackageName_argsStandardScheme getScheme() { + return new setPackageName_argsStandardScheme(); + } } - break; - } - } + private static class setPackageName_argsStandardScheme extends StandardScheme<setPackageName_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageName_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // 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(); - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, setPackageName_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + if (struct.name != null) { + oprot.writeFieldBegin(NAME_FIELD_DESC); + oprot.writeString(struct.name); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCollectorData_result) - return this.equals((getCollectorData_result)that); - return false; - } + } - public boolean equals(getCollectorData_result that) { - if (that == null) - return false; + private static class setPackageName_argsTupleSchemeFactory implements SchemeFactory { + public setPackageName_argsTupleScheme getScheme() { + return new setPackageName_argsTupleScheme(); + } + } - 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; - } + private static class setPackageName_argsTupleScheme extends TupleScheme<setPackageName_args> { - return true; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setPackageName_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + if (struct.isSetName()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + } - @Override - public int hashCode() { - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setPackageName_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + if (incoming.get(1)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + } + } - public int compareTo(getCollectorData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCollectorData_result typedOther = (getCollectorData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static class setPackageName_result implements org.apache.thrift.TBase<setPackageName_result, setPackageName_result._Fields>, java.io.Serializable, Cloneable, Comparable<setPackageName_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageName_result"); - 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("getCollectorData_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(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + schemes.put(StandardScheme.class, new setPackageName_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setPackageName_resultTupleSchemeFactory()); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - 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.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - private static class getCollectorData_resultStandardSchemeFactory implements SchemeFactory { - public getCollectorData_resultStandardScheme getScheme() { - return new getCollectorData_resultStandardScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class getCollectorData_resultStandardScheme extends StandardScheme<getCollectorData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCollectorData_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 _list206 = iprot.readListBegin(); - struct.success = new ArrayList<PackageData>(_list206.size); - for (int _i207 = 0; _i207 < _list206.size; ++_i207) - { - PackageData _elem208; // required - _elem208 = new PackageData(); - _elem208.read(iprot); - struct.success.add(_elem208); - } - iprot.readListEnd(); - } - 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, getCollectorData_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 (PackageData _iter209 : struct.success) - { - _iter209.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public setPackageName_result(android.os.Parcel in) { + } - } + public static final android.os.Parcelable.Creator<setPackageName_result> CREATOR = new android.os.Parcelable.Creator<setPackageName_result>() { + @Override + public setPackageName_result[] newArray(int size) { + return new setPackageName_result[size]; + } - private static class getCollectorData_resultTupleSchemeFactory implements SchemeFactory { - public getCollectorData_resultTupleScheme getScheme() { - return new getCollectorData_resultTupleScheme(); - } - } + @Override + public setPackageName_result createFromParcel(android.os.Parcel in) { + return new setPackageName_result(in); + } + }; - private static class getCollectorData_resultTupleScheme extends TupleScheme<getCollectorData_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCollectorData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (PackageData _iter210 : struct.success) - { - _iter210.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCollectorData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list211 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<PackageData>(_list211.size); - for (int _i212 = 0; _i212 < _list211.size; ++_i212) - { - PackageData _elem213; // required - _elem213 = new PackageData(); - _elem213.read(iprot); - struct.success.add(_elem213); - } - } - struct.setSuccessIsSet(true); - } - } - } + /** 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 Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public static class getPackageOrder_args implements org.apache.thrift.TBase<getPackageOrder_args, getPackageOrder_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageOrder_args"); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static final org.apache.thrift.protocol.TField DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short)1); + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageOrder_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageOrder_argsTupleSchemeFactory()); - } + /** + * 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; + } - /** - * - * @see Destination - */ - public Destination destination; // 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 Destination - */ - DESTINATION((short)1, "destination"); - - 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: // DESTINATION - return DESTINATION; - 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; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageOrder_args.class, metaDataMap); - } + private final short _thriftId; + private final String _fieldName; - public getPackageOrder_args() { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public getPackageOrder_args( - Destination destination) - { - this(); - this.destination = destination; - } + public short getThriftFieldId() { + return _thriftId; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageOrder_args(getPackageOrder_args other) { - if (other.isSetDestination()) { - this.destination = other.destination; - } - } + public String getFieldName() { + return _fieldName; + } + } - public getPackageOrder_args deepCopy() { - return new getPackageOrder_args(this); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void clear() { - this.destination = null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageName_result.class, metaDataMap); + } - /** - * - * @see Destination - */ - public Destination getDestination() { - return this.destination; - } + public setPackageName_result() { + } - /** - * - * @see Destination - */ - public getPackageOrder_args setDestination(Destination destination) { - this.destination = destination; - return this; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public setPackageName_result(setPackageName_result other) { + } - public void unsetDestination() { - this.destination = null; - } + public setPackageName_result deepCopy() { + return new setPackageName_result(this); + } - /** Returns true if field destination is set (has been assigned a value) and false otherwise */ - public boolean isSetDestination() { - return this.destination != null; - } + @Override + public void clear() { + } - public void setDestinationIsSet(boolean value) { - if (!value) { - this.destination = null; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + } + 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case DESTINATION: - if (value == null) { - unsetDestination(); - } else { - setDestination((Destination)value); + switch (field) { + } + throw new IllegalStateException(); } - break; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setPackageName_result) + return this.equals((setPackageName_result) that); + return false; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case DESTINATION: - return getDestination(); + public boolean equals(setPackageName_result that) { + if (that == null) + return false; - } - throw new IllegalStateException(); - } + return true; + } - /** 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 DESTINATION: - return isSetDestination(); - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageOrder_args) - return this.equals((getPackageOrder_args)that); - return false; - } + return list.hashCode(); + } - public boolean equals(getPackageOrder_args that) { - if (that == null) - return false; + @Override + public int compareTo(setPackageName_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - boolean this_present_destination = true && this.isSetDestination(); - boolean that_present_destination = true && that.isSetDestination(); - if (this_present_destination || that_present_destination) { - if (!(this_present_destination && that_present_destination)) - return false; - if (!this.destination.equals(that.destination)) - return false; - } + int lastComparison = 0; - return true; - } + return 0; + } - @Override - public int hashCode() { - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public int compareTo(getPackageOrder_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageOrder_args typedOther = (getPackageOrder_args)other; - - lastComparison = Boolean.valueOf(isSetDestination()).compareTo(typedOther.isSetDestination()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDestination()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, typedOther.destination); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("setPackageName_result("); + boolean first = true; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + sb.append(")"); + return sb.toString(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getPackageOrder_args("); - boolean first = true; - - sb.append("destination:"); - if (this.destination == null) { - sb.append("null"); - } else { - sb.append(this.destination); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static class setPackageName_resultStandardSchemeFactory implements SchemeFactory { + public setPackageName_resultStandardScheme getScheme() { + return new setPackageName_resultStandardScheme(); + } + } - private static class getPackageOrder_argsStandardSchemeFactory implements SchemeFactory { - public getPackageOrder_argsStandardScheme getScheme() { - return new getPackageOrder_argsStandardScheme(); - } - } + private static class setPackageName_resultStandardScheme extends StandardScheme<setPackageName_result> { - private static class getPackageOrder_argsStandardScheme extends StandardScheme<getPackageOrder_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageOrder_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: // DESTINATION - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(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, getPackageOrder_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.destination != null) { - oprot.writeFieldBegin(DESTINATION_FIELD_DESC); - oprot.writeI32(struct.destination.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageName_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) { + 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(); + } - private static class getPackageOrder_argsTupleSchemeFactory implements SchemeFactory { - public getPackageOrder_argsTupleScheme getScheme() { - return new getPackageOrder_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, setPackageName_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class getPackageOrder_argsTupleScheme extends TupleScheme<getPackageOrder_args> { + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetDestination()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetDestination()) { - oprot.writeI32(struct.destination.getValue()); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(true); + private static class setPackageName_resultTupleSchemeFactory implements SchemeFactory { + public setPackageName_resultTupleScheme getScheme() { + return new setPackageName_resultTupleScheme(); + } } - } - } - } + private static class setPackageName_resultTupleScheme extends TupleScheme<setPackageName_result> { - public static class getPackageOrder_result implements org.apache.thrift.TBase<getPackageOrder_result, getPackageOrder_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getPackageOrder_result"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setPackageName_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - 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); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setPackageName_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getPackageOrder_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getPackageOrder_resultTupleSchemeFactory()); } - public Map<Short,Integer> 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 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 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 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; - } - } + public static class movePackage_args implements org.apache.thrift.TBase<movePackage_args, movePackage_args._Fields>, java.io.Serializable, Cloneable, Comparable<movePackage_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("movePackage_args"); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getPackageOrder_result.class, metaDataMap); - } + private static final org.apache.thrift.protocol.TField DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 2); - public getPackageOrder_result() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public getPackageOrder_result( - Map<Short,Integer> success) - { - this(); - this.success = success; - } + static { + schemes.put(StandardScheme.class, new movePackage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new movePackage_argsTupleSchemeFactory()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getPackageOrder_result(getPackageOrder_result other) { - if (other.isSetSuccess()) { - Map<Short,Integer> __this__success = new HashMap<Short,Integer>(); - for (Map.Entry<Short, Integer> other_element : other.success.entrySet()) { + /** + * + * @see Destination + */ + public Destination destination; // required + public int pid; // required - Short other_element_key = other_element.getKey(); - Integer other_element_value = other_element.getValue(); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(destination.getValue()); + out.writeInt(pid); + } - Short __this__success_copy_key = other_element_key; + @Override + public int describeContents() { + return 0; + } - Integer __this__success_copy_value = other_element_value; + public movePackage_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - __this__success.put(__this__success_copy_key, __this__success_copy_value); + this.destination = Destination.findByValue(in.readInt()); + this.pid = in.readInt(); } - this.success = __this__success; - } - } - public getPackageOrder_result deepCopy() { - return new getPackageOrder_result(this); - } + public static final android.os.Parcelable.Creator<movePackage_args> CREATOR = new android.os.Parcelable.Creator<movePackage_args>() { + @Override + public movePackage_args[] newArray(int size) { + return new movePackage_args[size]; + } + + @Override + public movePackage_args createFromParcel(android.os.Parcel in) { + return new movePackage_args(in); + } + }; + + /** 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 Destination + */ + DESTINATION((short) 1, "destination"), + PID((short) 2, "pid"); + + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void clear() { - this.success = null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // DESTINATION + return DESTINATION; + case 2: // PID + return PID; + default: + return null; + } + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + /** + * 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; + } - public void putToSuccess(short key, int val) { - if (this.success == null) { - this.success = new HashMap<Short,Integer>(); - } - this.success.put(key, val); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public Map<Short,Integer> getSuccess() { - return this.success; - } + private final short _thriftId; + private final String _fieldName; - public getPackageOrder_result setSuccess(Map<Short,Integer> success) { - this.success = success; - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetSuccess() { - this.success = null; - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public String getFieldName() { + return _fieldName; + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<Short,Integer>)value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(movePackage_args.class, metaDataMap); } - break; - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public movePackage_args() { + } - } - throw new IllegalStateException(); - } + public movePackage_args( + Destination destination, + int pid) { + this(); + this.destination = destination; + this.pid = pid; + setPidIsSet(true); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public movePackage_args(movePackage_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetDestination()) { + this.destination = other.destination; + } + this.pid = other.pid; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getPackageOrder_result) - return this.equals((getPackageOrder_result)that); - return false; - } + public movePackage_args deepCopy() { + return new movePackage_args(this); + } - public boolean equals(getPackageOrder_result that) { - if (that == null) - return false; + @Override + public void clear() { + this.destination = null; + setPidIsSet(false); + this.pid = 0; + } - 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; - } + /** + * + * @see Destination + */ + public Destination getDestination() { + return this.destination; + } - return true; - } + /** + * + * @see Destination + */ + public movePackage_args setDestination(Destination destination) { + this.destination = destination; + return this; + } - @Override - public int hashCode() { - return 0; - } + public void unsetDestination() { + this.destination = null; + } - public int compareTo(getPackageOrder_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getPackageOrder_result typedOther = (getPackageOrder_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** Returns true if field destination is set (has been assigned a value) and false otherwise */ + public boolean isSetDestination() { + return this.destination != null; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void setDestinationIsSet(boolean value) { + if (!value) { + this.destination = null; + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public int getPid() { + return this.pid; + } - 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("getPackageOrder_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 movePackage_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - 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.getMessage()); - } - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - private static class getPackageOrder_resultStandardSchemeFactory implements SchemeFactory { - public getPackageOrder_resultStandardScheme getScheme() { - return new getPackageOrder_resultStandardScheme(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case DESTINATION: + if (value == null) { + unsetDestination(); + } else { + setDestination((Destination) value); + } + break; - private static class getPackageOrder_resultStandardScheme extends StandardScheme<getPackageOrder_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getPackageOrder_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 _map214 = iprot.readMapBegin(); - struct.success = new HashMap<Short,Integer>(2*_map214.size); - for (int _i215 = 0; _i215 < _map214.size; ++_i215) - { - short _key216; // required - int _val217; // required - _key216 = iprot.readI16(); - _val217 = iprot.readI32(); - struct.success.put(_key216, _val217); - } - iprot.readMapEnd(); - } - 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, getPackageOrder_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.I16, org.apache.thrift.protocol.TType.I32, struct.success.size())); - for (Map.Entry<Short, Integer> _iter218 : struct.success.entrySet()) - { - oprot.writeI16(_iter218.getKey()); - oprot.writeI32(_iter218.getValue()); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - } + } + } - private static class getPackageOrder_resultTupleSchemeFactory implements SchemeFactory { - public getPackageOrder_resultTupleScheme getScheme() { - return new getPackageOrder_resultTupleScheme(); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case DESTINATION: + return getDestination(); - private static class getPackageOrder_resultTupleScheme extends TupleScheme<getPackageOrder_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<Short, Integer> _iter219 : struct.success.entrySet()) - { - oprot.writeI16(_iter219.getKey()); - oprot.writeI32(_iter219.getValue()); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getPackageOrder_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map220 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I16, org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.success = new HashMap<Short,Integer>(2*_map220.size); - for (int _i221 = 0; _i221 < _map220.size; ++_i221) - { - short _key222; // required - int _val223; // required - _key222 = iprot.readI16(); - _val223 = iprot.readI32(); - struct.success.put(_key222, _val223); - } - } - struct.setSuccessIsSet(true); - } - } - } + case PID: + return getPid(); - } + } + throw new IllegalStateException(); + } - public static class getFileOrder_args implements org.apache.thrift.TBase<getFileOrder_args, getFileOrder_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileOrder_args"); + /** 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(); + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + switch (field) { + case DESTINATION: + return isSetDestination(); + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getFileOrder_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getFileOrder_argsTupleSchemeFactory()); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof movePackage_args) + return this.equals((movePackage_args) that); + return false; + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + public boolean equals(movePackage_args that) { + if (that == null) + return false; - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileOrder_args.class, metaDataMap); - } + boolean this_present_destination = true && this.isSetDestination(); + boolean that_present_destination = true && that.isSetDestination(); + if (this_present_destination || that_present_destination) { + if (!(this_present_destination && that_present_destination)) + return false; + if (!this.destination.equals(that.destination)) + return false; + } - public getFileOrder_args() { - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - public getFileOrder_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getFileOrder_args(getFileOrder_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public getFileOrder_args deepCopy() { - return new getFileOrder_args(this); - } + boolean present_destination = true && (isSetDestination()); + list.add(present_destination); + if (present_destination) + list.add(destination.getValue()); - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public int getPid() { - return this.pid; - } + return list.hashCode(); + } - public getFileOrder_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + @Override + public int compareTo(movePackage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + int lastComparison = 0; - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + lastComparison = Boolean.valueOf(isSetDestination()).compareTo(other.isSetDestination()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDestination()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, other.destination); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - break; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("movePackage_args("); + boolean first = true; - } - throw new IllegalStateException(); - } + sb.append("destination:"); + if (this.destination == null) { + sb.append("null"); + } else { + sb.append(this.destination); + } + first = false; + if (!first) sb.append(", "); + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getFileOrder_args) - return this.equals((getFileOrder_args)that); - return false; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(getFileOrder_args that) { - if (that == null) - return false; + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + private static class movePackage_argsStandardSchemeFactory implements SchemeFactory { + public movePackage_argsStandardScheme getScheme() { + return new movePackage_argsStandardScheme(); + } + } - return true; - } + private static class movePackage_argsStandardScheme extends StandardScheme<movePackage_args> { - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, movePackage_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: // DESTINATION + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - public int compareTo(getFileOrder_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getFileOrder_args typedOther = (getFileOrder_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, movePackage_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.destination != null) { + oprot.writeFieldBegin(DESTINATION_FIELD_DESC); + oprot.writeI32(struct.destination.getValue()); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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("getFileOrder_args("); - boolean first = true; + private static class movePackage_argsTupleSchemeFactory implements SchemeFactory { + public movePackage_argsTupleScheme getScheme() { + return new movePackage_argsTupleScheme(); + } + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + private static class movePackage_argsTupleScheme extends TupleScheme<movePackage_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, movePackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetDestination()) { + optionals.set(0); + } + if (struct.isSetPid()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetDestination()) { + oprot.writeI32(struct.destination.getValue()); + } + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, movePackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.destination = org.pyload.thrift.Destination.findByValue(iprot.readI32()); + struct.setDestinationIsSet(true); + } + if (incoming.get(1)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } } - private static class getFileOrder_argsStandardSchemeFactory implements SchemeFactory { - public getFileOrder_argsStandardScheme getScheme() { - return new getFileOrder_argsStandardScheme(); - } - } + public static class movePackage_result implements org.apache.thrift.TBase<movePackage_result, movePackage_result._Fields>, java.io.Serializable, Cloneable, Comparable<movePackage_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("movePackage_result"); - private static class getFileOrder_argsStandardScheme extends StandardScheme<getFileOrder_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getFileOrder_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, getFileOrder_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class getFileOrder_argsTupleSchemeFactory implements SchemeFactory { - public getFileOrder_argsTupleScheme getScheme() { - return new getFileOrder_argsTupleScheme(); - } - } + static { + schemes.put(StandardScheme.class, new movePackage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new movePackage_resultTupleSchemeFactory()); + } - private static class getFileOrder_argsTupleScheme extends TupleScheme<getFileOrder_args> { - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getFileOrder_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); + + @Override + public int describeContents() { + return 0; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getFileOrder_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + public movePackage_result(android.os.Parcel in) { } - } - } - } + public static final android.os.Parcelable.Creator<movePackage_result> CREATOR = new android.os.Parcelable.Creator<movePackage_result>() { + @Override + public movePackage_result[] newArray(int size) { + return new movePackage_result[size]; + } - public static class getFileOrder_result implements org.apache.thrift.TBase<getFileOrder_result, getFileOrder_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getFileOrder_result"); + @Override + public movePackage_result createFromParcel(android.os.Parcel in) { + return new movePackage_result(in); + } + }; - 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); + /** 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getFileOrder_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getFileOrder_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Map<Short,Integer> 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 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 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 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getFileOrder_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public getFileOrder_result() { - } + /** + * 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; + } - public getFileOrder_result( - Map<Short,Integer> success) - { - this(); - this.success = success; - } + /** + * 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; - /** - * Performs a deep copy on <i>other</i>. - */ - public getFileOrder_result(getFileOrder_result other) { - if (other.isSetSuccess()) { - Map<Short,Integer> __this__success = new HashMap<Short,Integer>(); - for (Map.Entry<Short, Integer> other_element : other.success.entrySet()) { + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - Short other_element_key = other_element.getKey(); - Integer other_element_value = other_element.getValue(); + public short getThriftFieldId() { + return _thriftId; + } - Short __this__success_copy_key = other_element_key; + public String getFieldName() { + return _fieldName; + } + } - Integer __this__success_copy_value = other_element_value; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - __this__success.put(__this__success_copy_key, __this__success_copy_value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(movePackage_result.class, metaDataMap); } - this.success = __this__success; - } - } - public getFileOrder_result deepCopy() { - return new getFileOrder_result(this); - } + public movePackage_result() { + } - @Override - public void clear() { - this.success = null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public movePackage_result(movePackage_result other) { + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public movePackage_result deepCopy() { + return new movePackage_result(this); + } - public void putToSuccess(short key, int val) { - if (this.success == null) { - this.success = new HashMap<Short,Integer>(); - } - this.success.put(key, val); - } + @Override + public void clear() { + } - public Map<Short,Integer> getSuccess() { - return this.success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public getFileOrder_result setSuccess(Map<Short,Integer> success) { - this.success = success; - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public void unsetSuccess() { - this.success = null; - } + /** 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(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + switch (field) { + } + throw new IllegalStateException(); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof movePackage_result) + return this.equals((movePackage_result) that); + return false; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<Short,Integer>)value); + public boolean equals(movePackage_result that) { + if (that == null) + return false; + + return true; } - break; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + return list.hashCode(); + } - } - throw new IllegalStateException(); - } + @Override + public int compareTo(movePackage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + int lastComparison = 0; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getFileOrder_result) - return this.equals((getFileOrder_result)that); - return false; - } + return 0; + } - public boolean equals(getFileOrder_result that) { - if (that == null) - return false; + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - return true; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("movePackage_result("); + boolean first = true; - public int compareTo(getFileOrder_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getFileOrder_result typedOther = (getFileOrder_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + sb.append(")"); + return sb.toString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - 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("getFileOrder_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(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class movePackage_resultStandardSchemeFactory implements SchemeFactory { + public movePackage_resultStandardScheme getScheme() { + return new movePackage_resultStandardScheme(); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class movePackage_resultStandardScheme extends StandardScheme<movePackage_result> { - 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.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, movePackage_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - private static class getFileOrder_resultStandardSchemeFactory implements SchemeFactory { - public getFileOrder_resultStandardScheme getScheme() { - return new getFileOrder_resultStandardScheme(); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static class getFileOrder_resultStandardScheme extends StandardScheme<getFileOrder_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getFileOrder_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 _map224 = iprot.readMapBegin(); - struct.success = new HashMap<Short,Integer>(2*_map224.size); - for (int _i225 = 0; _i225 < _map224.size; ++_i225) - { - short _key226; // required - int _val227; // required - _key226 = iprot.readI16(); - _val227 = iprot.readI32(); - struct.success.put(_key226, _val227); - } - iprot.readMapEnd(); - } - 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, getFileOrder_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.I16, org.apache.thrift.protocol.TType.I32, struct.success.size())); - for (Map.Entry<Short, Integer> _iter228 : struct.success.entrySet()) - { - oprot.writeI16(_iter228.getKey()); - oprot.writeI32(_iter228.getValue()); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, movePackage_result struct) throws org.apache.thrift.TException { + struct.validate(); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class getFileOrder_resultTupleSchemeFactory implements SchemeFactory { - public getFileOrder_resultTupleScheme getScheme() { - return new getFileOrder_resultTupleScheme(); - } - } + } - private static class getFileOrder_resultTupleScheme extends TupleScheme<getFileOrder_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getFileOrder_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<Short, Integer> _iter229 : struct.success.entrySet()) - { - oprot.writeI16(_iter229.getKey()); - oprot.writeI32(_iter229.getValue()); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getFileOrder_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map230 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I16, org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.success = new HashMap<Short,Integer>(2*_map230.size); - for (int _i231 = 0; _i231 < _map230.size; ++_i231) - { - short _key232; // required - int _val233; // required - _key232 = iprot.readI16(); - _val233 = iprot.readI32(); - struct.success.put(_key232, _val233); - } - } - struct.setSuccessIsSet(true); - } - } - } + private static class movePackage_resultTupleSchemeFactory implements SchemeFactory { + public movePackage_resultTupleScheme getScheme() { + return new movePackage_resultTupleScheme(); + } + } - } + private static class movePackage_resultTupleScheme extends TupleScheme<movePackage_result> { - public static class generateAndAddPackages_args implements org.apache.thrift.TBase<generateAndAddPackages_args, generateAndAddPackages_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generateAndAddPackages_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, movePackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short)1); - private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short)2); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, movePackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new generateAndAddPackages_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new generateAndAddPackages_argsTupleSchemeFactory()); } - public List<String> links; // required - /** - * - * @see Destination - */ - public Destination dest; // 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 { - LINKS((short)1, "links"), - /** - * - * @see Destination - */ - DEST((short)2, "dest"); - - 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: // LINKS - return LINKS; - case 2: // DEST - return DEST; - 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; - } - } + public static class moveFiles_args implements org.apache.thrift.TBase<moveFiles_args, moveFiles_args._Fields>, java.io.Serializable, Cloneable, Comparable<moveFiles_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("moveFiles_args"); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generateAndAddPackages_args.class, metaDataMap); - } + private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short) 1); + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 2); - public generateAndAddPackages_args() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public generateAndAddPackages_args( - List<String> links, - Destination dest) - { - this(); - this.links = links; - this.dest = dest; - } + static { + schemes.put(StandardScheme.class, new moveFiles_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new moveFiles_argsTupleSchemeFactory()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public generateAndAddPackages_args(generateAndAddPackages_args other) { - if (other.isSetLinks()) { - this.links = other.links; - } - if (other.isSetDest()) { - this.dest = other.dest; - } - } + public List<Integer> fids; // required + public int pid; // required - public generateAndAddPackages_args deepCopy() { - return new generateAndAddPackages_args(this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void clear() { - this.links = null; - this.dest = null; - } + out.writeList(fids); + out.writeInt(pid); + } - public int getLinksSize() { - return (this.links == null) ? 0 : this.links.size(); - } + @Override + public int describeContents() { + return 0; + } - public java.util.Iterator<String> getLinksIterator() { - return (this.links == null) ? null : this.links.iterator(); - } + public moveFiles_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void addToLinks(String elem) { - if (this.links == null) { - this.links = new ArrayList<String>(); - } - this.links.add(elem); - } + this.fids = new ArrayList<Integer>(); + in.readList(this.fids, moveFiles_args.class.getClassLoader()); + this.pid = in.readInt(); + } - public List<String> getLinks() { - return this.links; - } + public static final android.os.Parcelable.Creator<moveFiles_args> CREATOR = new android.os.Parcelable.Creator<moveFiles_args>() { + @Override + public moveFiles_args[] newArray(int size) { + return new moveFiles_args[size]; + } - public generateAndAddPackages_args setLinks(List<String> links) { - this.links = links; - return this; - } + @Override + public moveFiles_args createFromParcel(android.os.Parcel in) { + return new moveFiles_args(in); + } + }; - public void unsetLinks() { - this.links = null; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FIDS((short) 1, "fids"), + PID((short) 2, "pid"); - /** Returns true if field links is set (has been assigned a value) and false otherwise */ - public boolean isSetLinks() { - return this.links != null; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void setLinksIsSet(boolean value) { - if (!value) { - this.links = null; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** - * - * @see Destination - */ - public Destination getDest() { - return this.dest; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FIDS + return FIDS; + case 2: // PID + return PID; + default: + return null; + } + } - /** - * - * @see Destination - */ - public generateAndAddPackages_args setDest(Destination dest) { - this.dest = dest; - return this; - } + /** + * 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; + } - public void unsetDest() { - this.dest = null; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** Returns true if field dest is set (has been assigned a value) and false otherwise */ - public boolean isSetDest() { - return this.dest != null; - } + private final short _thriftId; + private final String _fieldName; - public void setDestIsSet(boolean value) { - if (!value) { - this.dest = null; - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case LINKS: - if (value == null) { - unsetLinks(); - } else { - setLinks((List<String>)value); - } - break; + public short getThriftFieldId() { + return _thriftId; + } - case DEST: - if (value == null) { - unsetDest(); - } else { - setDest((Destination)value); + public String getFieldName() { + return _fieldName; + } } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case LINKS: - return getLinks(); + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - case DEST: - return getDest(); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32, "FileID")))); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(moveFiles_args.class, metaDataMap); + } - } - throw new IllegalStateException(); - } + public moveFiles_args() { + } - /** 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 LINKS: - return isSetLinks(); - case DEST: - return isSetDest(); - } - throw new IllegalStateException(); - } + public moveFiles_args( + List<Integer> fids, + int pid) { + this(); + this.fids = fids; + this.pid = pid; + setPidIsSet(true); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof generateAndAddPackages_args) - return this.equals((generateAndAddPackages_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public moveFiles_args(moveFiles_args other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetFids()) { + List<Integer> __this__fids = new ArrayList<Integer>(other.fids.size()); + for (Integer other_element : other.fids) { + __this__fids.add(other_element); + } + this.fids = __this__fids; + } + this.pid = other.pid; + } - public boolean equals(generateAndAddPackages_args that) { - if (that == null) - return false; - - boolean this_present_links = true && this.isSetLinks(); - boolean that_present_links = true && that.isSetLinks(); - if (this_present_links || that_present_links) { - if (!(this_present_links && that_present_links)) - return false; - if (!this.links.equals(that.links)) - return false; - } - - boolean this_present_dest = true && this.isSetDest(); - boolean that_present_dest = true && that.isSetDest(); - if (this_present_dest || that_present_dest) { - if (!(this_present_dest && that_present_dest)) - return false; - if (!this.dest.equals(that.dest)) - return false; - } - - return true; - } + public moveFiles_args deepCopy() { + return new moveFiles_args(this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public void clear() { + this.fids = null; + setPidIsSet(false); + this.pid = 0; + } - public int compareTo(generateAndAddPackages_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - generateAndAddPackages_args typedOther = (generateAndAddPackages_args)other; - - lastComparison = Boolean.valueOf(isSetLinks()).compareTo(typedOther.isSetLinks()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinks()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, typedOther.links); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDest()).compareTo(typedOther.isSetDest()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDest()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, typedOther.dest); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public int getFidsSize() { + return (this.fids == null) ? 0 : this.fids.size(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public java.util.Iterator<Integer> getFidsIterator() { + return (this.fids == null) ? null : this.fids.iterator(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void addToFids(int elem) { + if (this.fids == null) { + this.fids = new ArrayList<Integer>(); + } + this.fids.add(elem); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public List<Integer> getFids() { + return this.fids; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("generateAndAddPackages_args("); - boolean first = true; - - sb.append("links:"); - if (this.links == null) { - sb.append("null"); - } else { - sb.append(this.links); - } - first = false; - if (!first) sb.append(", "); - sb.append("dest:"); - if (this.dest == null) { - sb.append("null"); - } else { - sb.append(this.dest); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public moveFiles_args setFids(List<Integer> fids) { + this.fids = fids; + return this; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void unsetFids() { + this.fids = null; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** Returns true if field fids is set (has been assigned a value) and false otherwise */ + public boolean isSetFids() { + return this.fids != null; + } - 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.getMessage()); - } - } + public void setFidsIsSet(boolean value) { + if (!value) { + this.fids = null; + } + } - private static class generateAndAddPackages_argsStandardSchemeFactory implements SchemeFactory { - public generateAndAddPackages_argsStandardScheme getScheme() { - return new generateAndAddPackages_argsStandardScheme(); - } - } + public int getPid() { + return this.pid; + } - private static class generateAndAddPackages_argsStandardScheme extends StandardScheme<generateAndAddPackages_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, generateAndAddPackages_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: // LINKS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list234 = iprot.readListBegin(); - struct.links = new ArrayList<String>(_list234.size); - for (int _i235 = 0; _i235 < _list234.size; ++_i235) - { - String _elem236; // required - _elem236 = iprot.readString(); - struct.links.add(_elem236); - } - iprot.readListEnd(); - } - struct.setLinksIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // DEST - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(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, generateAndAddPackages_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.links != null) { - oprot.writeFieldBegin(LINKS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); - for (String _iter237 : struct.links) - { - oprot.writeString(_iter237); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - if (struct.dest != null) { - oprot.writeFieldBegin(DEST_FIELD_DESC); - oprot.writeI32(struct.dest.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public moveFiles_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - private static class generateAndAddPackages_argsTupleSchemeFactory implements SchemeFactory { - public generateAndAddPackages_argsTupleScheme getScheme() { - return new generateAndAddPackages_argsTupleScheme(); - } - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - private static class generateAndAddPackages_argsTupleScheme extends TupleScheme<generateAndAddPackages_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetLinks()) { - optionals.set(0); - } - if (struct.isSetDest()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetLinks()) { - { - oprot.writeI32(struct.links.size()); - for (String _iter238 : struct.links) - { - oprot.writeString(_iter238); - } - } - } - if (struct.isSetDest()) { - oprot.writeI32(struct.dest.getValue()); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list239 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.links = new ArrayList<String>(_list239.size); - for (int _i240 = 0; _i240 < _list239.size; ++_i240) - { - String _elem241; // required - _elem241 = iprot.readString(); - struct.links.add(_elem241); - } - } - struct.setLinksIsSet(true); - } - if (incoming.get(1)) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(true); - } - } - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FIDS: + if (value == null) { + unsetFids(); + } else { + setFids((List<Integer>) value); + } + break; - public static class generateAndAddPackages_result implements org.apache.thrift.TBase<generateAndAddPackages_result, generateAndAddPackages_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("generateAndAddPackages_result"); + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new generateAndAddPackages_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new generateAndAddPackages_resultTupleSchemeFactory()); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FIDS: + return getFids(); - public List<Integer> 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 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 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 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; - } - } + case PID: + return getPid(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(generateAndAddPackages_result.class, metaDataMap); - } + } + throw new IllegalStateException(); + } - public generateAndAddPackages_result() { - } + /** 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(); + } - public generateAndAddPackages_result( - List<Integer> success) - { - this(); - this.success = success; - } + switch (field) { + case FIDS: + return isSetFids(); + case PID: + return isSetPid(); + } + throw new IllegalStateException(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public generateAndAddPackages_result(generateAndAddPackages_result other) { - if (other.isSetSuccess()) { - List<Integer> __this__success = new ArrayList<Integer>(); - for (Integer other_element : other.success) { - __this__success.add(other_element); - } - this.success = __this__success; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof moveFiles_args) + return this.equals((moveFiles_args) that); + return false; + } - public generateAndAddPackages_result deepCopy() { - return new generateAndAddPackages_result(this); - } + public boolean equals(moveFiles_args that) { + if (that == null) + return false; - @Override - public void clear() { - this.success = null; - } + boolean this_present_fids = true && this.isSetFids(); + boolean that_present_fids = true && that.isSetFids(); + if (this_present_fids || that_present_fids) { + if (!(this_present_fids && that_present_fids)) + return false; + if (!this.fids.equals(that.fids)) + return false; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - public java.util.Iterator<Integer> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + return true; + } - public void addToSuccess(int elem) { - if (this.success == null) { - this.success = new ArrayList<Integer>(); - } - this.success.add(elem); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public List<Integer> getSuccess() { - return this.success; - } + boolean present_fids = true && (isSetFids()); + list.add(present_fids); + if (present_fids) + list.add(fids); - public generateAndAddPackages_result setSuccess(List<Integer> success) { - this.success = success; - return this; - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public void unsetSuccess() { - this.success = null; - } + return list.hashCode(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + @Override + public int compareTo(moveFiles_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + int lastComparison = 0; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<Integer>)value); + lastComparison = Boolean.valueOf(isSetFids()).compareTo(other.isSetFids()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFids()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, other.fids); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; } - break; - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - } - throw new IllegalStateException(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof generateAndAddPackages_result) - return this.equals((generateAndAddPackages_result)that); - return false; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("moveFiles_args("); + boolean first = true; - public boolean equals(generateAndAddPackages_result that) { - if (that == null) - return false; + sb.append("fids:"); + if (this.fids == null) { + sb.append("null"); + } else { + sb.append(this.fids); + } + first = false; + if (!first) sb.append(", "); + sb.append("pid:"); + sb.append(this.pid); + first = false; + sb.append(")"); + return sb.toString(); + } - 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; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - return true; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public int hashCode() { - return 0; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public int compareTo(generateAndAddPackages_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - generateAndAddPackages_result typedOther = (generateAndAddPackages_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static class moveFiles_argsStandardSchemeFactory implements SchemeFactory { + public moveFiles_argsStandardScheme getScheme() { + return new moveFiles_argsStandardScheme(); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class moveFiles_argsStandardScheme extends StandardScheme<moveFiles_args> { - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, moveFiles_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: // FIDS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list314 = iprot.readListBegin(); + struct.fids = new ArrayList<Integer>(_list314.size); + int _elem315; + for (int _i316 = 0; _i316 < _list314.size; ++_i316) { + _elem315 = iprot.readI32(); + struct.fids.add(_elem315); + } + iprot.readListEnd(); + } + struct.setFidsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(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(); - 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("generateAndAddPackages_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(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void write(org.apache.thrift.protocol.TProtocol oprot, moveFiles_args struct) throws org.apache.thrift.TException { + struct.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.getMessage()); - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.fids != null) { + oprot.writeFieldBegin(FIDS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); + for (int _iter317 : struct.fids) { + oprot.writeI32(_iter317); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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.getMessage()); - } - } + } - private static class generateAndAddPackages_resultStandardSchemeFactory implements SchemeFactory { - public generateAndAddPackages_resultStandardScheme getScheme() { - return new generateAndAddPackages_resultStandardScheme(); - } - } + private static class moveFiles_argsTupleSchemeFactory implements SchemeFactory { + public moveFiles_argsTupleScheme getScheme() { + return new moveFiles_argsTupleScheme(); + } + } - private static class generateAndAddPackages_resultStandardScheme extends StandardScheme<generateAndAddPackages_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, generateAndAddPackages_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 _list242 = iprot.readListBegin(); - struct.success = new ArrayList<Integer>(_list242.size); - for (int _i243 = 0; _i243 < _list242.size; ++_i243) - { - int _elem244; // required - _elem244 = iprot.readI32(); - struct.success.add(_elem244); - } - iprot.readListEnd(); - } - 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, generateAndAddPackages_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.I32, struct.success.size())); - for (int _iter245 : struct.success) - { - oprot.writeI32(_iter245); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static class moveFiles_argsTupleScheme extends TupleScheme<moveFiles_args> { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, moveFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFids()) { + optionals.set(0); + } + if (struct.isSetPid()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetFids()) { + { + oprot.writeI32(struct.fids.size()); + for (int _iter318 : struct.fids) { + oprot.writeI32(_iter318); + } + } + } + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + } - private static class generateAndAddPackages_resultTupleSchemeFactory implements SchemeFactory { - public generateAndAddPackages_resultTupleScheme getScheme() { - return new generateAndAddPackages_resultTupleScheme(); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, moveFiles_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list319 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.fids = new ArrayList<Integer>(_list319.size); + int _elem320; + for (int _i321 = 0; _i321 < _list319.size; ++_i321) { + _elem320 = iprot.readI32(); + struct.fids.add(_elem320); + } + } + struct.setFidsIsSet(true); + } + if (incoming.get(1)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + } + } - private static class generateAndAddPackages_resultTupleScheme extends TupleScheme<generateAndAddPackages_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (int _iter246 : struct.success) - { - oprot.writeI32(_iter246); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, generateAndAddPackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list247 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.success = new ArrayList<Integer>(_list247.size); - for (int _i248 = 0; _i248 < _list247.size; ++_i248) - { - int _elem249; // required - _elem249 = iprot.readI32(); - struct.success.add(_elem249); - } - } - struct.setSuccessIsSet(true); - } - } } - } + public static class moveFiles_result implements org.apache.thrift.TBase<moveFiles_result, moveFiles_result._Fields>, java.io.Serializable, Cloneable, Comparable<moveFiles_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("moveFiles_result"); - public static class addPackage_args implements org.apache.thrift.TBase<addPackage_args, addPackage_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addPackage_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.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short)2); - private static final org.apache.thrift.protocol.TField DEST_FIELD_DESC = new org.apache.thrift.protocol.TField("dest", org.apache.thrift.protocol.TType.I32, (short)3); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new addPackage_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new addPackage_argsTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new moveFiles_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new moveFiles_resultTupleSchemeFactory()); + } - public String name; // required - public List<String> links; // required - /** - * - * @see Destination - */ - public Destination dest; // 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"), - LINKS((short)2, "links"), - /** - * - * @see Destination - */ - DEST((short)3, "dest"); - - 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: // LINKS - return LINKS; - case 3: // DEST - return DEST; - default: - return null; - } - } - - /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. - */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.NAME, new org.apache.thrift.meta_data.FieldMetaData("name", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - tmpMap.put(_Fields.DEST, new org.apache.thrift.meta_data.FieldMetaData("dest", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addPackage_args.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public addPackage_args() { - } + @Override + public int describeContents() { + return 0; + } - public addPackage_args( - String name, - List<String> links, - Destination dest) - { - this(); - this.name = name; - this.links = links; - this.dest = dest; - } + public moveFiles_result(android.os.Parcel in) { + } - /** - * Performs a deep copy on <i>other</i>. - */ - public addPackage_args(addPackage_args other) { - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetLinks()) { - this.links = other.links; - } - if (other.isSetDest()) { - this.dest = other.dest; - } - } + public static final android.os.Parcelable.Creator<moveFiles_result> CREATOR = new android.os.Parcelable.Creator<moveFiles_result>() { + @Override + public moveFiles_result[] newArray(int size) { + return new moveFiles_result[size]; + } - public addPackage_args deepCopy() { - return new addPackage_args(this); - } + @Override + public moveFiles_result createFromParcel(android.os.Parcel in) { + return new moveFiles_result(in); + } + }; - @Override - public void clear() { - this.name = null; - this.links = null; - this.dest = null; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public String getName() { - return this.name; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public addPackage_args setName(String name) { - this.name = name; - return this; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void unsetName() { - this.name = null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != 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; + } - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public int getLinksSize() { - return (this.links == null) ? 0 : this.links.size(); - } + private final short _thriftId; + private final String _fieldName; - public java.util.Iterator<String> getLinksIterator() { - return (this.links == null) ? null : this.links.iterator(); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void addToLinks(String elem) { - if (this.links == null) { - this.links = new ArrayList<String>(); - } - this.links.add(elem); - } + public short getThriftFieldId() { + return _thriftId; + } - public List<String> getLinks() { - return this.links; - } + public String getFieldName() { + return _fieldName; + } + } - public addPackage_args setLinks(List<String> links) { - this.links = links; - return this; - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void unsetLinks() { - this.links = null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(moveFiles_result.class, metaDataMap); + } - /** Returns true if field links is set (has been assigned a value) and false otherwise */ - public boolean isSetLinks() { - return this.links != null; - } + public moveFiles_result() { + } - public void setLinksIsSet(boolean value) { - if (!value) { - this.links = null; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public moveFiles_result(moveFiles_result other) { + } - /** - * - * @see Destination - */ - public Destination getDest() { - return this.dest; - } + public moveFiles_result deepCopy() { + return new moveFiles_result(this); + } - /** - * - * @see Destination - */ - public addPackage_args setDest(Destination dest) { - this.dest = dest; - return this; - } + @Override + public void clear() { + } - public void unsetDest() { - this.dest = null; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - /** Returns true if field dest is set (has been assigned a value) and false otherwise */ - public boolean isSetDest() { - return this.dest != null; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public void setDestIsSet(boolean value) { - if (!value) { - this.dest = null; - } - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); + switch (field) { + } + throw new IllegalStateException(); } - break; - case LINKS: - if (value == null) { - unsetLinks(); - } else { - setLinks((List<String>)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof moveFiles_result) + return this.equals((moveFiles_result) that); + return false; } - break; - case DEST: - if (value == null) { - unsetDest(); - } else { - setDest((Destination)value); - } - break; + public boolean equals(moveFiles_result that) { + if (that == null) + return false; - } - } + return true; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case NAME: - return getName(); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - case LINKS: - return getLinks(); + return list.hashCode(); + } - case DEST: - return getDest(); + @Override + public int compareTo(moveFiles_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - } - throw new IllegalStateException(); - } + int lastComparison = 0; - /** 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 LINKS: - return isSetLinks(); - case DEST: - return isSetDest(); - } - throw new IllegalStateException(); - } + return 0; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof addPackage_args) - return this.equals((addPackage_args)that); - return false; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public boolean equals(addPackage_args 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_links = true && this.isSetLinks(); - boolean that_present_links = true && that.isSetLinks(); - if (this_present_links || that_present_links) { - if (!(this_present_links && that_present_links)) - return false; - if (!this.links.equals(that.links)) - return false; - } - - boolean this_present_dest = true && this.isSetDest(); - boolean that_present_dest = true && that.isSetDest(); - if (this_present_dest || that_present_dest) { - if (!(this_present_dest && that_present_dest)) - return false; - if (!this.dest.equals(that.dest)) - return false; - } - - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - @Override - public int hashCode() { - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public int compareTo(addPackage_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - addPackage_args typedOther = (addPackage_args)other; - - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLinks()).compareTo(typedOther.isSetLinks()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinks()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, typedOther.links); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDest()).compareTo(typedOther.isSetDest()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDest()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.dest, typedOther.dest); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("moveFiles_result("); + boolean first = true; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + sb.append(")"); + return sb.toString(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("addPackage_args("); - boolean first = true; - - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("links:"); - if (this.links == null) { - sb.append("null"); - } else { - sb.append(this.links); - } - first = false; - if (!first) sb.append(", "); - sb.append("dest:"); - if (this.dest == null) { - sb.append("null"); - } else { - sb.append(this.dest); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class moveFiles_resultStandardSchemeFactory implements SchemeFactory { + public moveFiles_resultStandardScheme getScheme() { + return new moveFiles_resultStandardScheme(); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class moveFiles_resultStandardScheme extends StandardScheme<moveFiles_result> { - 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.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, moveFiles_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - private static class addPackage_argsStandardSchemeFactory implements SchemeFactory { - public addPackage_argsStandardScheme getScheme() { - return new addPackage_argsStandardScheme(); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static class addPackage_argsStandardScheme extends StandardScheme<addPackage_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, addPackage_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; - case 2: // LINKS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list250 = iprot.readListBegin(); - struct.links = new ArrayList<String>(_list250.size); - for (int _i251 = 0; _i251 < _list250.size; ++_i251) - { - String _elem252; // required - _elem252 = iprot.readString(); - struct.links.add(_elem252); - } - iprot.readListEnd(); - } - struct.setLinksIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 3: // DEST - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(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, addPackage_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(); - } - if (struct.links != null) { - oprot.writeFieldBegin(LINKS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); - for (String _iter253 : struct.links) - { - oprot.writeString(_iter253); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - if (struct.dest != null) { - oprot.writeFieldBegin(DEST_FIELD_DESC); - oprot.writeI32(struct.dest.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, moveFiles_result struct) throws org.apache.thrift.TException { + struct.validate(); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class addPackage_argsTupleSchemeFactory implements SchemeFactory { - public addPackage_argsTupleScheme getScheme() { - return new addPackage_argsTupleScheme(); - } - } + } - private static class addPackage_argsTupleScheme extends TupleScheme<addPackage_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, addPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetName()) { - optionals.set(0); - } - if (struct.isSetLinks()) { - optionals.set(1); - } - if (struct.isSetDest()) { - optionals.set(2); - } - oprot.writeBitSet(optionals, 3); - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetLinks()) { - { - oprot.writeI32(struct.links.size()); - for (String _iter254 : struct.links) - { - oprot.writeString(_iter254); - } - } - } - if (struct.isSetDest()) { - oprot.writeI32(struct.dest.getValue()); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, addPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); - if (incoming.get(0)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(1)) { - { - org.apache.thrift.protocol.TList _list255 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.links = new ArrayList<String>(_list255.size); - for (int _i256 = 0; _i256 < _list255.size; ++_i256) - { - String _elem257; // required - _elem257 = iprot.readString(); - struct.links.add(_elem257); - } - } - struct.setLinksIsSet(true); - } - if (incoming.get(2)) { - struct.dest = Destination.findByValue(iprot.readI32()); - struct.setDestIsSet(true); - } - } - } + private static class moveFiles_resultTupleSchemeFactory implements SchemeFactory { + public moveFiles_resultTupleScheme getScheme() { + return new moveFiles_resultTupleScheme(); + } + } - } + private static class moveFiles_resultTupleScheme extends TupleScheme<moveFiles_result> { - public static class addPackage_result implements org.apache.thrift.TBase<addPackage_result, addPackage_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addPackage_result"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, moveFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - 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); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, moveFiles_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new addPackage_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new addPackage_resultTupleSchemeFactory()); } - public int 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 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 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 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; - } - } + public static class orderPackage_args implements org.apache.thrift.TBase<orderPackage_args, orderPackage_args._Fields>, java.io.Serializable, Cloneable, Comparable<orderPackage_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderPackage_args"); - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addPackage_result.class, metaDataMap); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField POSITION_FIELD_DESC = new org.apache.thrift.protocol.TField("position", org.apache.thrift.protocol.TType.I16, (short) 2); - public addPackage_result() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public addPackage_result( - int success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + static { + schemes.put(StandardScheme.class, new orderPackage_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new orderPackage_argsTupleSchemeFactory()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public addPackage_result(addPackage_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + public int pid; // required + public short position; // required - public addPackage_result deepCopy() { - return new addPackage_result(this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void clear() { - setSuccessIsSet(false); - this.success = 0; - } + out.writeInt(pid); + out.writeInt(new Short(position).intValue()); + } - public int getSuccess() { - return this.success; - } + @Override + public int describeContents() { + return 0; + } - public addPackage_result setSuccess(int success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + public orderPackage_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + this.pid = in.readInt(); + this.position = (short) in.readInt(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + public static final android.os.Parcelable.Creator<orderPackage_args> CREATOR = new android.os.Parcelable.Creator<orderPackage_args>() { + @Override + public orderPackage_args[] newArray(int size) { + return new orderPackage_args[size]; + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + @Override + public orderPackage_args createFromParcel(android.os.Parcel in) { + return new orderPackage_args(in); + } + }; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Integer)value); - } - break; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"), + POSITION((short) 2, "position"); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Integer.valueOf(getSuccess()); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + case 2: // POSITION + return POSITION; + default: + return null; + } + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + /** + * 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; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof addPackage_result) - return this.equals((addPackage_result)that); - return false; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public boolean equals(addPackage_result that) { - if (that == null) - return false; + private final short _thriftId; + private final String _fieldName; - 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; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - return true; - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public int hashCode() { - return 0; - } + public String getFieldName() { + return _fieldName; + } + } - public int compareTo(addPackage_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - addPackage_result typedOther = (addPackage_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private static final int __POSITION_ISSET_ID = 1; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.POSITION, new org.apache.thrift.meta_data.FieldMetaData("position", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderPackage_args.class, metaDataMap); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public orderPackage_args() { + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public orderPackage_args( + int pid, + short position) { + this(); + this.pid = pid; + setPidIsSet(true); + this.position = position; + setPositionIsSet(true); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("addPackage_result("); - boolean first = true; + /** + * Performs a deep copy on <i>other</i>. + */ + public orderPackage_args(orderPackage_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + this.position = other.position; + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + public orderPackage_args deepCopy() { + return new orderPackage_args(this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + setPositionIsSet(false); + this.position = 0; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public int getPid() { + return this.pid; + } - 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.getMessage()); - } - } + public orderPackage_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - private static class addPackage_resultStandardSchemeFactory implements SchemeFactory { - public addPackage_resultStandardScheme getScheme() { - return new addPackage_resultStandardScheme(); - } - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - private static class addPackage_resultStandardScheme extends StandardScheme<addPackage_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, addPackage_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; - 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, addPackage_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeI32(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - private static class addPackage_resultTupleSchemeFactory implements SchemeFactory { - public addPackage_resultTupleScheme getScheme() { - return new addPackage_resultTupleScheme(); - } - } + public short getPosition() { + return this.position; + } - private static class addPackage_resultTupleScheme extends TupleScheme<addPackage_result> { + public orderPackage_args setPosition(short position) { + this.position = position; + setPositionIsSet(true); + return this; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, addPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + public void unsetPosition() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __POSITION_ISSET_ID); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeI32(struct.success); + + /** Returns true if field position is set (has been assigned a value) and false otherwise */ + public boolean isSetPosition() { + return EncodingUtils.testBit(__isset_bitfield, __POSITION_ISSET_ID); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, addPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readI32(); - struct.setSuccessIsSet(true); + public void setPositionIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __POSITION_ISSET_ID, value); } - } - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; - public static class addFiles_args implements org.apache.thrift.TBase<addFiles_args, addFiles_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addFiles_args"); + case POSITION: + if (value == null) { + unsetPosition(); + } else { + setPosition((Short) value); + } + break; - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField LINKS_FIELD_DESC = new org.apache.thrift.protocol.TField("links", org.apache.thrift.protocol.TType.LIST, (short)2); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new addFiles_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new addFiles_argsTupleSchemeFactory()); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - public int pid; // required - public List<String> links; // 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 { - PID((short)1, "pid"), - LINKS((short)2, "links"); - - 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: // PID - return PID; - case 2: // LINKS - return LINKS; - 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; - } - } + case POSITION: + return getPosition(); - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.LINKS, new org.apache.thrift.meta_data.FieldMetaData("links", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.LIST , "LinkList"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addFiles_args.class, metaDataMap); - } + } + throw new IllegalStateException(); + } - public addFiles_args() { - } + /** 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(); + } - public addFiles_args( - int pid, - List<String> links) - { - this(); - this.pid = pid; - setPidIsSet(true); - this.links = links; - } + switch (field) { + case PID: + return isSetPid(); + case POSITION: + return isSetPosition(); + } + throw new IllegalStateException(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public addFiles_args(addFiles_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - if (other.isSetLinks()) { - this.links = other.links; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof orderPackage_args) + return this.equals((orderPackage_args) that); + return false; + } - public addFiles_args deepCopy() { - return new addFiles_args(this); - } + public boolean equals(orderPackage_args that) { + if (that == null) + return false; - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - this.links = null; - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - public int getPid() { - return this.pid; - } + boolean this_present_position = true; + boolean that_present_position = true; + if (this_present_position || that_present_position) { + if (!(this_present_position && that_present_position)) + return false; + if (this.position != that.position) + return false; + } - public addFiles_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + return true; + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + boolean present_position = true; + list.add(present_position); + if (present_position) + list.add(position); - public int getLinksSize() { - return (this.links == null) ? 0 : this.links.size(); - } + return list.hashCode(); + } - public java.util.Iterator<String> getLinksIterator() { - return (this.links == null) ? null : this.links.iterator(); - } + @Override + public int compareTo(orderPackage_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void addToLinks(String elem) { - if (this.links == null) { - this.links = new ArrayList<String>(); - } - this.links.add(elem); - } + int lastComparison = 0; - public List<String> getLinks() { - return this.links; - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPosition()).compareTo(other.isSetPosition()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPosition()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.position, other.position); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public addFiles_args setLinks(List<String> links) { - this.links = links; - return this; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void unsetLinks() { - this.links = null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - /** Returns true if field links is set (has been assigned a value) and false otherwise */ - public boolean isSetLinks() { - return this.links != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void setLinksIsSet(boolean value) { - if (!value) { - this.links = null; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("orderPackage_args("); + boolean first = true; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + sb.append("pid:"); + sb.append(this.pid); + first = false; + if (!first) sb.append(", "); + sb.append("position:"); + sb.append(this.position); + first = false; + sb.append(")"); + return sb.toString(); } - break; - case LINKS: - if (value == null) { - unsetLinks(); - } else { - setLinks((List<String>)value); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - break; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - case LINKS: - return getLinks(); + private static class orderPackage_argsStandardSchemeFactory implements SchemeFactory { + public orderPackage_argsStandardScheme getScheme() { + return new orderPackage_argsStandardScheme(); + } + } - } - throw new IllegalStateException(); - } + private static class orderPackage_argsStandardScheme extends StandardScheme<orderPackage_args> { - /** 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 PID: - return isSetPid(); - case LINKS: - return isSetLinks(); - } - throw new IllegalStateException(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, orderPackage_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // POSITION + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.position = iprot.readI16(); + struct.setPositionIsSet(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(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof addFiles_args) - return this.equals((addFiles_args)that); - return false; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public boolean equals(addFiles_args that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } - - boolean this_present_links = true && this.isSetLinks(); - boolean that_present_links = true && that.isSetLinks(); - if (this_present_links || that_present_links) { - if (!(this_present_links && that_present_links)) - return false; - if (!this.links.equals(that.links)) - return false; - } - - return true; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, orderPackage_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(POSITION_FIELD_DESC); + oprot.writeI16(struct.position); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public int hashCode() { - return 0; - } + } - public int compareTo(addFiles_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - addFiles_args typedOther = (addFiles_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetLinks()).compareTo(typedOther.isSetLinks()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetLinks()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.links, typedOther.links); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static class orderPackage_argsTupleSchemeFactory implements SchemeFactory { + public orderPackage_argsTupleScheme getScheme() { + return new orderPackage_argsTupleScheme(); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class orderPackage_argsTupleScheme extends TupleScheme<orderPackage_args> { - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, orderPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + if (struct.isSetPosition()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + if (struct.isSetPosition()) { + oprot.writeI16(struct.position); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, orderPackage_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + if (incoming.get(1)) { + struct.position = iprot.readI16(); + struct.setPositionIsSet(true); + } + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("addFiles_args("); - boolean first = true; - - sb.append("pid:"); - sb.append(this.pid); - first = false; - if (!first) sb.append(", "); - sb.append("links:"); - if (this.links == null) { - sb.append("null"); - } else { - sb.append(this.links); - } - first = false; - sb.append(")"); - return sb.toString(); } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public static class orderPackage_result implements org.apache.thrift.TBase<orderPackage_result, orderPackage_result._Fields>, java.io.Serializable, Cloneable, Comparable<orderPackage_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderPackage_result"); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class addFiles_argsStandardSchemeFactory implements SchemeFactory { - public addFiles_argsStandardScheme getScheme() { - return new addFiles_argsStandardScheme(); - } - } + static { + schemes.put(StandardScheme.class, new orderPackage_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new orderPackage_resultTupleSchemeFactory()); + } - private static class addFiles_argsStandardScheme extends StandardScheme<addFiles_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, addFiles_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // LINKS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list258 = iprot.readListBegin(); - struct.links = new ArrayList<String>(_list258.size); - for (int _i259 = 0; _i259 < _list258.size; ++_i259) - { - String _elem260; // required - _elem260 = iprot.readString(); - struct.links.add(_elem260); - } - iprot.readListEnd(); - } - struct.setLinksIsSet(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, addFiles_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - if (struct.links != null) { - oprot.writeFieldBegin(LINKS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.links.size())); - for (String _iter261 : struct.links) - { - oprot.writeString(_iter261); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - private static class addFiles_argsTupleSchemeFactory implements SchemeFactory { - public addFiles_argsTupleScheme getScheme() { - return new addFiles_argsTupleScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class addFiles_argsTupleScheme extends TupleScheme<addFiles_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, addFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - if (struct.isSetLinks()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - if (struct.isSetLinks()) { - { - oprot.writeI32(struct.links.size()); - for (String _iter262 : struct.links) - { - oprot.writeString(_iter262); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, addFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } - if (incoming.get(1)) { - { - org.apache.thrift.protocol.TList _list263 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.links = new ArrayList<String>(_list263.size); - for (int _i264 = 0; _i264 < _list263.size; ++_i264) - { - String _elem265; // required - _elem265 = iprot.readString(); - struct.links.add(_elem265); - } - } - struct.setLinksIsSet(true); - } - } - } + public orderPackage_result(android.os.Parcel in) { + } - } + public static final android.os.Parcelable.Creator<orderPackage_result> CREATOR = new android.os.Parcelable.Creator<orderPackage_result>() { + @Override + public orderPackage_result[] newArray(int size) { + return new orderPackage_result[size]; + } - public static class addFiles_result implements org.apache.thrift.TBase<addFiles_result, addFiles_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("addFiles_result"); + @Override + public orderPackage_result createFromParcel(android.os.Parcel in) { + return new orderPackage_result(in); + } + }; + /** 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new addFiles_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new addFiles_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(addFiles_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public addFiles_result() { - } + /** + * 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; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public addFiles_result(addFiles_result other) { - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public addFiles_result deepCopy() { - return new addFiles_result(this); - } + private final short _thriftId; + private final String _fieldName; - @Override - public void clear() { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public short getThriftFieldId() { + return _thriftId; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public String getFieldName() { + return _fieldName; + } + } - /** 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(); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - switch (field) { - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderPackage_result.class, metaDataMap); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof addFiles_result) - return this.equals((addFiles_result)that); - return false; - } + public orderPackage_result() { + } - public boolean equals(addFiles_result that) { - if (that == null) - return false; + /** + * Performs a deep copy on <i>other</i>. + */ + public orderPackage_result(orderPackage_result other) { + } - return true; - } + public orderPackage_result deepCopy() { + return new orderPackage_result(this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public void clear() { + } - public int compareTo(addFiles_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - int lastComparison = 0; - addFiles_result typedOther = (addFiles_result)other; + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - return 0; - } + /** 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(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + switch (field) { + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof orderPackage_result) + return this.equals((orderPackage_result) that); + return false; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public boolean equals(orderPackage_result that) { + if (that == null) + return false; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("addFiles_result("); - boolean first = true; + return true; + } - sb.append(")"); - return sb.toString(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(orderPackage_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - 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.getMessage()); - } - } + int lastComparison = 0; - private static class addFiles_resultStandardSchemeFactory implements SchemeFactory { - public addFiles_resultStandardScheme getScheme() { - return new addFiles_resultStandardScheme(); - } - } + return 0; + } - private static class addFiles_resultStandardScheme extends StandardScheme<addFiles_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, addFiles_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) { - 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, addFiles_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class addFiles_resultTupleSchemeFactory implements SchemeFactory { - public addFiles_resultTupleScheme getScheme() { - return new addFiles_resultTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class addFiles_resultTupleScheme extends TupleScheme<addFiles_result> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("orderPackage_result("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, addFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + sb.append(")"); + return sb.toString(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, addFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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); + } + } - public static class uploadContainer_args implements org.apache.thrift.TBase<uploadContainer_args, uploadContainer_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("uploadContainer_args"); + 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 final org.apache.thrift.protocol.TField FILENAME_FIELD_DESC = new org.apache.thrift.protocol.TField("filename", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.STRING, (short)2); + private static class orderPackage_resultStandardSchemeFactory implements SchemeFactory { + public orderPackage_resultStandardScheme getScheme() { + return new orderPackage_resultStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new uploadContainer_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new uploadContainer_argsTupleSchemeFactory()); - } + private static class orderPackage_resultStandardScheme extends StandardScheme<orderPackage_result> { - public String filename; // required - public ByteBuffer data; // 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 { - FILENAME((short)1, "filename"), - DATA((short)2, "data"); - - 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: // FILENAME - return FILENAME; - case 2: // DATA - return DATA; - 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; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, orderPackage_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FILENAME, new org.apache.thrift.meta_data.FieldMetaData("filename", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , true))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(uploadContainer_args.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public uploadContainer_args() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, orderPackage_result struct) throws org.apache.thrift.TException { + struct.validate(); - public uploadContainer_args( - String filename, - ByteBuffer data) - { - this(); - this.filename = filename; - this.data = data; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public uploadContainer_args(uploadContainer_args other) { - if (other.isSetFilename()) { - this.filename = other.filename; - } - if (other.isSetData()) { - this.data = org.apache.thrift.TBaseHelper.copyBinary(other.data); -; - } - } + } - public uploadContainer_args deepCopy() { - return new uploadContainer_args(this); - } + private static class orderPackage_resultTupleSchemeFactory implements SchemeFactory { + public orderPackage_resultTupleScheme getScheme() { + return new orderPackage_resultTupleScheme(); + } + } - @Override - public void clear() { - this.filename = null; - this.data = null; - } + private static class orderPackage_resultTupleScheme extends TupleScheme<orderPackage_result> { - public String getFilename() { - return this.filename; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, orderPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public uploadContainer_args setFilename(String filename) { - this.filename = filename; - return this; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, orderPackage_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public void unsetFilename() { - this.filename = null; } - /** Returns true if field filename is set (has been assigned a value) and false otherwise */ - public boolean isSetFilename() { - return this.filename != null; - } + public static class orderFile_args implements org.apache.thrift.TBase<orderFile_args, orderFile_args._Fields>, java.io.Serializable, Cloneable, Comparable<orderFile_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderFile_args"); - public void setFilenameIsSet(boolean value) { - if (!value) { - this.filename = null; - } - } + private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField POSITION_FIELD_DESC = new org.apache.thrift.protocol.TField("position", org.apache.thrift.protocol.TType.I16, (short) 2); - public byte[] getData() { - setData(org.apache.thrift.TBaseHelper.rightSize(data)); - return data == null ? null : data.array(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public ByteBuffer bufferForData() { - return data; - } + static { + schemes.put(StandardScheme.class, new orderFile_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new orderFile_argsTupleSchemeFactory()); + } - public uploadContainer_args setData(byte[] data) { - setData(data == null ? (ByteBuffer)null : ByteBuffer.wrap(data)); - return this; - } + public int fid; // required + public short position; // required - public uploadContainer_args setData(ByteBuffer data) { - this.data = data; - return this; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public void unsetData() { - this.data = null; - } + out.writeInt(fid); + out.writeInt(new Short(position).intValue()); + } - /** Returns true if field data is set (has been assigned a value) and false otherwise */ - public boolean isSetData() { - return this.data != null; - } + @Override + public int describeContents() { + return 0; + } - public void setDataIsSet(boolean value) { - if (!value) { - this.data = null; - } - } + public orderFile_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FILENAME: - if (value == null) { - unsetFilename(); - } else { - setFilename((String)value); + this.fid = in.readInt(); + this.position = (short) in.readInt(); } - break; - case DATA: - if (value == null) { - unsetData(); - } else { - setData((ByteBuffer)value); - } - break; + public static final android.os.Parcelable.Creator<orderFile_args> CREATOR = new android.os.Parcelable.Creator<orderFile_args>() { + @Override + public orderFile_args[] newArray(int size) { + return new orderFile_args[size]; + } - } - } + @Override + public orderFile_args createFromParcel(android.os.Parcel in) { + return new orderFile_args(in); + } + }; - public Object getFieldValue(_Fields field) { - switch (field) { - case FILENAME: - return getFilename(); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + FID((short) 1, "fid"), + POSITION((short) 2, "position"); - case DATA: - return getData(); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - } - throw new IllegalStateException(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** 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 FILENAME: - return isSetFilename(); - case DATA: - return isSetData(); - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // FID + return FID; + case 2: // POSITION + return POSITION; + default: + return null; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof uploadContainer_args) - return this.equals((uploadContainer_args)that); - return false; - } + /** + * 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; + } - public boolean equals(uploadContainer_args that) { - if (that == null) - return false; - - boolean this_present_filename = true && this.isSetFilename(); - boolean that_present_filename = true && that.isSetFilename(); - if (this_present_filename || that_present_filename) { - if (!(this_present_filename && that_present_filename)) - return false; - if (!this.filename.equals(that.filename)) - return false; - } - - boolean this_present_data = true && this.isSetData(); - boolean that_present_data = true && that.isSetData(); - if (this_present_data || that_present_data) { - if (!(this_present_data && that_present_data)) - return false; - if (!this.data.equals(that.data)) - return false; - } - - return true; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public int hashCode() { - return 0; - } + private final short _thriftId; + private final String _fieldName; - public int compareTo(uploadContainer_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - uploadContainer_args typedOther = (uploadContainer_args)other; - - lastComparison = Boolean.valueOf(isSetFilename()).compareTo(typedOther.isSetFilename()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFilename()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.filename, typedOther.filename); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetData()).compareTo(typedOther.isSetData()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetData()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, typedOther.data); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public short getThriftFieldId() { + return _thriftId; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public String getFieldName() { + return _fieldName; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + // isset id assignments + private static final int __FID_ISSET_ID = 0; + private static final int __POSITION_ISSET_ID = 1; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("uploadContainer_args("); - boolean first = true; - - sb.append("filename:"); - if (this.filename == null) { - sb.append("null"); - } else { - sb.append(this.filename); - } - first = false; - if (!first) sb.append(", "); - sb.append("data:"); - if (this.data == null) { - sb.append("null"); - } else { - org.apache.thrift.TBaseHelper.toString(this.data, sb); - } - first = false; - sb.append(")"); - return sb.toString(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "FileID"))); + tmpMap.put(_Fields.POSITION, new org.apache.thrift.meta_data.FieldMetaData("position", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderFile_args.class, metaDataMap); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public orderFile_args() { + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public orderFile_args( + int fid, + short position) { + this(); + this.fid = fid; + setFidIsSet(true); + this.position = position; + setPositionIsSet(true); + } - 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.getMessage()); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public orderFile_args(orderFile_args other) { + __isset_bitfield = other.__isset_bitfield; + this.fid = other.fid; + this.position = other.position; + } - private static class uploadContainer_argsStandardSchemeFactory implements SchemeFactory { - public uploadContainer_argsStandardScheme getScheme() { - return new uploadContainer_argsStandardScheme(); - } - } + public orderFile_args deepCopy() { + return new orderFile_args(this); + } + + @Override + public void clear() { + setFidIsSet(false); + this.fid = 0; + setPositionIsSet(false); + this.position = 0; + } + + public int getFid() { + return this.fid; + } - private static class uploadContainer_argsStandardScheme extends StandardScheme<uploadContainer_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, uploadContainer_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: // FILENAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.filename = iprot.readString(); - struct.setFilenameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // DATA - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(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, uploadContainer_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.filename != null) { - oprot.writeFieldBegin(FILENAME_FIELD_DESC); - oprot.writeString(struct.filename); - oprot.writeFieldEnd(); - } - if (struct.data != null) { - oprot.writeFieldBegin(DATA_FIELD_DESC); - oprot.writeBinary(struct.data); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public orderFile_args setFid(int fid) { + this.fid = fid; + setFidIsSet(true); + return this; + } - } + public void unsetFid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __FID_ISSET_ID); + } - private static class uploadContainer_argsTupleSchemeFactory implements SchemeFactory { - public uploadContainer_argsTupleScheme getScheme() { - return new uploadContainer_argsTupleScheme(); - } - } + /** Returns true if field fid is set (has been assigned a value) and false otherwise */ + public boolean isSetFid() { + return EncodingUtils.testBit(__isset_bitfield, __FID_ISSET_ID); + } - private static class uploadContainer_argsTupleScheme extends TupleScheme<uploadContainer_args> { + public void setFidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __FID_ISSET_ID, value); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, uploadContainer_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFilename()) { - optionals.set(0); + public short getPosition() { + return this.position; } - if (struct.isSetData()) { - optionals.set(1); + + public orderFile_args setPosition(short position) { + this.position = position; + setPositionIsSet(true); + return this; } - oprot.writeBitSet(optionals, 2); - if (struct.isSetFilename()) { - oprot.writeString(struct.filename); + + public void unsetPosition() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __POSITION_ISSET_ID); } - if (struct.isSetData()) { - oprot.writeBinary(struct.data); + + /** Returns true if field position is set (has been assigned a value) and false otherwise */ + public boolean isSetPosition() { + return EncodingUtils.testBit(__isset_bitfield, __POSITION_ISSET_ID); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, uploadContainer_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.filename = iprot.readString(); - struct.setFilenameIsSet(true); + public void setPositionIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __POSITION_ISSET_ID, value); } - if (incoming.get(1)) { - struct.data = iprot.readBinary(); - struct.setDataIsSet(true); + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case FID: + if (value == null) { + unsetFid(); + } else { + setFid((Integer) value); + } + break; + + case POSITION: + if (value == null) { + unsetPosition(); + } else { + setPosition((Short) value); + } + break; + + } } - } - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case FID: + return getFid(); - public static class uploadContainer_result implements org.apache.thrift.TBase<uploadContainer_result, uploadContainer_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("uploadContainer_result"); + case POSITION: + return getPosition(); + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new uploadContainer_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new uploadContainer_resultTupleSchemeFactory()); - } + /** 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 FID: + return isSetFid(); + case POSITION: + return isSetPosition(); + } + throw new IllegalStateException(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(uploadContainer_result.class, metaDataMap); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof orderFile_args) + return this.equals((orderFile_args) that); + return false; + } - public uploadContainer_result() { - } + public boolean equals(orderFile_args that) { + if (that == null) + return false; - /** - * Performs a deep copy on <i>other</i>. - */ - public uploadContainer_result(uploadContainer_result other) { - } + boolean this_present_fid = true; + boolean that_present_fid = true; + if (this_present_fid || that_present_fid) { + if (!(this_present_fid && that_present_fid)) + return false; + if (this.fid != that.fid) + return false; + } - public uploadContainer_result deepCopy() { - return new uploadContainer_result(this); - } + boolean this_present_position = true; + boolean that_present_position = true; + if (this_present_position || that_present_position) { + if (!(this_present_position && that_present_position)) + return false; + if (this.position != that.position) + return false; + } - @Override - public void clear() { - } + return true; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + boolean present_fid = true; + list.add(present_fid); + if (present_fid) + list.add(fid); - /** 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(); - } + boolean present_position = true; + list.add(present_position); + if (present_position) + list.add(position); - switch (field) { - } - throw new IllegalStateException(); - } + return list.hashCode(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof uploadContainer_result) - return this.equals((uploadContainer_result)that); - return false; - } + @Override + public int compareTo(orderFile_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public boolean equals(uploadContainer_result that) { - if (that == null) - return false; + int lastComparison = 0; - return true; - } + lastComparison = Boolean.valueOf(isSetFid()).compareTo(other.isSetFid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, other.fid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPosition()).compareTo(other.isSetPosition()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPosition()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.position, other.position); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - @Override - public int hashCode() { - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public int compareTo(uploadContainer_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - int lastComparison = 0; - uploadContainer_result typedOther = (uploadContainer_result)other; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - return 0; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("orderFile_args("); + boolean first = true; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + sb.append("fid:"); + sb.append(this.fid); + first = false; + if (!first) sb.append(", "); + sb.append("position:"); + sb.append(this.position); + first = false; + sb.append(")"); + return sb.toString(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("uploadContainer_result("); - boolean first = true; + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - sb.append(")"); - return sb.toString(); - } + private static class orderFile_argsStandardSchemeFactory implements SchemeFactory { + public orderFile_argsStandardScheme getScheme() { + return new orderFile_argsStandardScheme(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class orderFile_argsStandardScheme extends StandardScheme<orderFile_args> { - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, orderFile_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: // FID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // POSITION + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.position = iprot.readI16(); + struct.setPositionIsSet(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(); - 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.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static class uploadContainer_resultStandardSchemeFactory implements SchemeFactory { - public uploadContainer_resultStandardScheme getScheme() { - return new uploadContainer_resultStandardScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, orderFile_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(FID_FIELD_DESC); + oprot.writeI32(struct.fid); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(POSITION_FIELD_DESC); + oprot.writeI16(struct.position); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class uploadContainer_resultStandardScheme extends StandardScheme<uploadContainer_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, uploadContainer_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) { - 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, uploadContainer_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } - } + private static class orderFile_argsTupleSchemeFactory implements SchemeFactory { + public orderFile_argsTupleScheme getScheme() { + return new orderFile_argsTupleScheme(); + } + } - private static class uploadContainer_resultTupleSchemeFactory implements SchemeFactory { - public uploadContainer_resultTupleScheme getScheme() { - return new uploadContainer_resultTupleScheme(); - } - } + private static class orderFile_argsTupleScheme extends TupleScheme<orderFile_args> { - private static class uploadContainer_resultTupleScheme extends TupleScheme<uploadContainer_result> { + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, orderFile_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetFid()) { + optionals.set(0); + } + if (struct.isSetPosition()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetFid()) { + oprot.writeI32(struct.fid); + } + if (struct.isSetPosition()) { + oprot.writeI16(struct.position); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, uploadContainer_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, orderFile_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.fid = iprot.readI32(); + struct.setFidIsSet(true); + } + if (incoming.get(1)) { + struct.position = iprot.readI16(); + struct.setPositionIsSet(true); + } + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, uploadContainer_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } } - } + public static class orderFile_result implements org.apache.thrift.TBase<orderFile_result, orderFile_result._Fields>, java.io.Serializable, Cloneable, Comparable<orderFile_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderFile_result"); - public static class deleteFiles_args implements org.apache.thrift.TBase<deleteFiles_args, deleteFiles_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFiles_args"); - private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short)1); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deleteFiles_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deleteFiles_argsTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new orderFile_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new orderFile_resultTupleSchemeFactory()); + } - public List<Integer> fids; // 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 { - FIDS((short)1, "fids"); - - 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: // FIDS - return FIDS; - default: - return null; - } - } - - /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. - */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32 , "FileID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFiles_args.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public deleteFiles_args() { - } + @Override + public int describeContents() { + return 0; + } - public deleteFiles_args( - List<Integer> fids) - { - this(); - this.fids = fids; - } + public orderFile_result(android.os.Parcel in) { + } - /** - * Performs a deep copy on <i>other</i>. - */ - public deleteFiles_args(deleteFiles_args other) { - if (other.isSetFids()) { - List<Integer> __this__fids = new ArrayList<Integer>(); - for (Integer other_element : other.fids) { - __this__fids.add(other_element); - } - this.fids = __this__fids; - } - } + public static final android.os.Parcelable.Creator<orderFile_result> CREATOR = new android.os.Parcelable.Creator<orderFile_result>() { + @Override + public orderFile_result[] newArray(int size) { + return new orderFile_result[size]; + } - public deleteFiles_args deepCopy() { - return new deleteFiles_args(this); - } + @Override + public orderFile_result createFromParcel(android.os.Parcel in) { + return new orderFile_result(in); + } + }; - @Override - public void clear() { - this.fids = null; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public int getFidsSize() { - return (this.fids == null) ? 0 : this.fids.size(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public java.util.Iterator<Integer> getFidsIterator() { - return (this.fids == null) ? null : this.fids.iterator(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void addToFids(int elem) { - if (this.fids == null) { - this.fids = new ArrayList<Integer>(); - } - this.fids.add(elem); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public List<Integer> getFids() { - return this.fids; - } + /** + * 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; + } - public deleteFiles_args setFids(List<Integer> fids) { - this.fids = fids; - return this; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void unsetFids() { - this.fids = null; - } + private final short _thriftId; + private final String _fieldName; - /** Returns true if field fids is set (has been assigned a value) and false otherwise */ - public boolean isSetFids() { - return this.fids != null; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFidsIsSet(boolean value) { - if (!value) { - this.fids = null; - } - } + public short getThriftFieldId() { + return _thriftId; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FIDS: - if (value == null) { - unsetFids(); - } else { - setFids((List<Integer>)value); + public String getFieldName() { + return _fieldName; + } } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case FIDS: - return getFids(); + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderFile_result.class, metaDataMap); + } - /** 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 FIDS: - return isSetFids(); - } - throw new IllegalStateException(); - } + public orderFile_result() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deleteFiles_args) - return this.equals((deleteFiles_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public orderFile_result(orderFile_result other) { + } - public boolean equals(deleteFiles_args that) { - if (that == null) - return false; + public orderFile_result deepCopy() { + return new orderFile_result(this); + } - boolean this_present_fids = true && this.isSetFids(); - boolean that_present_fids = true && that.isSetFids(); - if (this_present_fids || that_present_fids) { - if (!(this_present_fids && that_present_fids)) - return false; - if (!this.fids.equals(that.fids)) - return false; - } + @Override + public void clear() { + } - return true; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - @Override - public int hashCode() { - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public int compareTo(deleteFiles_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - deleteFiles_args typedOther = (deleteFiles_args)other; - - lastComparison = Boolean.valueOf(isSetFids()).compareTo(typedOther.isSetFids()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFids()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, typedOther.fids); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** 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(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + switch (field) { + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof orderFile_result) + return this.equals((orderFile_result) that); + return false; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public boolean equals(orderFile_result that) { + if (that == null) + return false; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("deleteFiles_args("); - boolean first = true; - - sb.append("fids:"); - if (this.fids == null) { - sb.append("null"); - } else { - sb.append(this.fids); - } - first = false; - sb.append(")"); - return sb.toString(); - } + return true; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return list.hashCode(); + } - 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.getMessage()); - } - } + @Override + public int compareTo(orderFile_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class deleteFiles_argsStandardSchemeFactory implements SchemeFactory { - public deleteFiles_argsStandardScheme getScheme() { - return new deleteFiles_argsStandardScheme(); - } - } + int lastComparison = 0; - private static class deleteFiles_argsStandardScheme extends StandardScheme<deleteFiles_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFiles_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: // FIDS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list266 = iprot.readListBegin(); - struct.fids = new ArrayList<Integer>(_list266.size); - for (int _i267 = 0; _i267 < _list266.size; ++_i267) - { - int _elem268; // required - _elem268 = iprot.readI32(); - struct.fids.add(_elem268); - } - iprot.readListEnd(); - } - struct.setFidsIsSet(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, deleteFiles_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.fids != null) { - oprot.writeFieldBegin(FIDS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); - for (int _iter269 : struct.fids) - { - oprot.writeI32(_iter269); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return 0; + } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class deleteFiles_argsTupleSchemeFactory implements SchemeFactory { - public deleteFiles_argsTupleScheme getScheme() { - return new deleteFiles_argsTupleScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class deleteFiles_argsTupleScheme extends TupleScheme<deleteFiles_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deleteFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFids()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetFids()) { - { - oprot.writeI32(struct.fids.size()); - for (int _iter270 : struct.fids) - { - oprot.writeI32(_iter270); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deleteFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list271 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.fids = new ArrayList<Integer>(_list271.size); - for (int _i272 = 0; _i272 < _list271.size; ++_i272) - { - int _elem273; // required - _elem273 = iprot.readI32(); - struct.fids.add(_elem273); - } - } - struct.setFidsIsSet(true); - } - } - } + 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("orderFile_result("); + boolean first = true; - public static class deleteFiles_result implements org.apache.thrift.TBase<deleteFiles_result, deleteFiles_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFiles_result"); + sb.append(")"); + return sb.toString(); + } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deleteFiles_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deleteFiles_resultTupleSchemeFactory()); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(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); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFiles_result.class, metaDataMap); - } + private static class orderFile_resultStandardSchemeFactory implements SchemeFactory { + public orderFile_resultStandardScheme getScheme() { + return new orderFile_resultStandardScheme(); + } + } - public deleteFiles_result() { - } + private static class orderFile_resultStandardScheme extends StandardScheme<orderFile_result> { - /** - * Performs a deep copy on <i>other</i>. - */ - public deleteFiles_result(deleteFiles_result other) { - } + public void read(org.apache.thrift.protocol.TProtocol iprot, orderFile_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public deleteFiles_result deepCopy() { - return new deleteFiles_result(this); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void clear() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, orderFile_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); - } + private static class orderFile_resultTupleSchemeFactory implements SchemeFactory { + public orderFile_resultTupleScheme getScheme() { + return new orderFile_resultTupleScheme(); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + private static class orderFile_resultTupleScheme extends TupleScheme<orderFile_result> { - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deleteFiles_result) - return this.equals((deleteFiles_result)that); - return false; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, orderFile_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public boolean equals(deleteFiles_result that) { - if (that == null) - return false; + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, orderFile_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - return true; } - @Override - public int hashCode() { - return 0; - } + public static class setPackageData_args implements org.apache.thrift.TBase<setPackageData_args, setPackageData_args._Fields>, java.io.Serializable, Cloneable, Comparable<setPackageData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageData_args"); - public int compareTo(deleteFiles_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.MAP, (short) 2); - int lastComparison = 0; - deleteFiles_result typedOther = (deleteFiles_result)other; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - return 0; - } + static { + schemes.put(StandardScheme.class, new setPackageData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setPackageData_argsTupleSchemeFactory()); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public int pid; // required + public Map<String, String> data; // required - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + out.writeInt(pid); + out.writeMap(data); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("deleteFiles_result("); - boolean first = true; + @Override + public int describeContents() { + return 0; + } - sb.append(")"); - return sb.toString(); - } + public setPackageData_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + this.pid = in.readInt(); + this.data = new HashMap<String, String>(); + in.readMap(this.data, setPackageData_args.class.getClassLoader()); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public static final android.os.Parcelable.Creator<setPackageData_args> CREATOR = new android.os.Parcelable.Creator<setPackageData_args>() { + @Override + public setPackageData_args[] newArray(int size) { + return new setPackageData_args[size]; + } - 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.getMessage()); - } - } + @Override + public setPackageData_args createFromParcel(android.os.Parcel in) { + return new setPackageData_args(in); + } + }; - private static class deleteFiles_resultStandardSchemeFactory implements SchemeFactory { - public deleteFiles_resultStandardScheme getScheme() { - return new deleteFiles_resultStandardScheme(); - } - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PID((short) 1, "pid"), + DATA((short) 2, "data"); - private static class deleteFiles_resultStandardScheme extends StandardScheme<deleteFiles_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFiles_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) { - 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, deleteFiles_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class deleteFiles_resultTupleSchemeFactory implements SchemeFactory { - public deleteFiles_resultTupleScheme getScheme() { - return new deleteFiles_resultTupleScheme(); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PID + return PID; + case 2: // DATA + return DATA; + default: + return null; + } + } - private static class deleteFiles_resultTupleScheme extends TupleScheme<deleteFiles_result> { + /** + * 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; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deleteFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deleteFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public static class deletePackages_args implements org.apache.thrift.TBase<deletePackages_args, deletePackages_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deletePackages_args"); + public short getThriftFieldId() { + return _thriftId; + } - private static final org.apache.thrift.protocol.TField PIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("pids", org.apache.thrift.protocol.TType.LIST, (short)1); + public String getFieldName() { + return _fieldName; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deletePackages_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deletePackages_argsTupleSchemeFactory()); - } + // isset id assignments + private static final int __PID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + 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.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID"))); + tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageData_args.class, metaDataMap); + } + + public setPackageData_args() { + } + + public setPackageData_args( + int pid, + Map<String, String> data) { + this(); + this.pid = pid; + setPidIsSet(true); + this.data = data; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public setPackageData_args(setPackageData_args other) { + __isset_bitfield = other.__isset_bitfield; + this.pid = other.pid; + if (other.isSetData()) { + Map<String, String> __this__data = new HashMap<String, String>(other.data); + this.data = __this__data; + } + } - public List<Integer> pids; // 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 { - PIDS((short)1, "pids"); - - 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: // PIDS - return PIDS; - 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; - } - } + public setPackageData_args deepCopy() { + return new setPackageData_args(this); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PIDS, new org.apache.thrift.meta_data.FieldMetaData("pids", 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.I32 , "PackageID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deletePackages_args.class, metaDataMap); - } + @Override + public void clear() { + setPidIsSet(false); + this.pid = 0; + this.data = null; + } - public deletePackages_args() { - } + public int getPid() { + return this.pid; + } - public deletePackages_args( - List<Integer> pids) - { - this(); - this.pids = pids; - } + public setPackageData_args setPid(int pid) { + this.pid = pid; + setPidIsSet(true); + return this; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public deletePackages_args(deletePackages_args other) { - if (other.isSetPids()) { - List<Integer> __this__pids = new ArrayList<Integer>(); - for (Integer other_element : other.pids) { - __this__pids.add(other_element); - } - this.pids = __this__pids; - } - } + public void unsetPid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PID_ISSET_ID); + } - public deletePackages_args deepCopy() { - return new deletePackages_args(this); - } + /** Returns true if field pid is set (has been assigned a value) and false otherwise */ + public boolean isSetPid() { + return EncodingUtils.testBit(__isset_bitfield, __PID_ISSET_ID); + } - @Override - public void clear() { - this.pids = null; - } + public void setPidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PID_ISSET_ID, value); + } - public int getPidsSize() { - return (this.pids == null) ? 0 : this.pids.size(); - } + public int getDataSize() { + return (this.data == null) ? 0 : this.data.size(); + } - public java.util.Iterator<Integer> getPidsIterator() { - return (this.pids == null) ? null : this.pids.iterator(); - } + public void putToData(String key, String val) { + if (this.data == null) { + this.data = new HashMap<String, String>(); + } + this.data.put(key, val); + } - public void addToPids(int elem) { - if (this.pids == null) { - this.pids = new ArrayList<Integer>(); - } - this.pids.add(elem); - } + public Map<String, String> getData() { + return this.data; + } - public List<Integer> getPids() { - return this.pids; - } + public setPackageData_args setData(Map<String, String> data) { + this.data = data; + return this; + } - public deletePackages_args setPids(List<Integer> pids) { - this.pids = pids; - return this; - } + public void unsetData() { + this.data = null; + } - public void unsetPids() { - this.pids = null; - } + /** Returns true if field data is set (has been assigned a value) and false otherwise */ + public boolean isSetData() { + return this.data != null; + } - /** Returns true if field pids is set (has been assigned a value) and false otherwise */ - public boolean isSetPids() { - return this.pids != null; - } + public void setDataIsSet(boolean value) { + if (!value) { + this.data = null; + } + } - public void setPidsIsSet(boolean value) { - if (!value) { - this.pids = null; - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PID: + if (value == null) { + unsetPid(); + } else { + setPid((Integer) value); + } + break; + + case DATA: + if (value == null) { + unsetData(); + } else { + setData((Map<String, String>) value); + } + break; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PIDS: - if (value == null) { - unsetPids(); - } else { - setPids((List<Integer>)value); + } } - break; - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PID: + return getPid(); - public Object getFieldValue(_Fields field) { - switch (field) { - case PIDS: - return getPids(); + case DATA: + return getData(); - } - throw new IllegalStateException(); - } + } + 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(); + } - /** 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 PIDS: - return isSetPids(); - } - throw new IllegalStateException(); - } + switch (field) { + case PID: + return isSetPid(); + case DATA: + return isSetData(); + } + throw new IllegalStateException(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deletePackages_args) - return this.equals((deletePackages_args)that); - return false; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setPackageData_args) + return this.equals((setPackageData_args) that); + return false; + } - public boolean equals(deletePackages_args that) { - if (that == null) - return false; + public boolean equals(setPackageData_args that) { + if (that == null) + return false; - boolean this_present_pids = true && this.isSetPids(); - boolean that_present_pids = true && that.isSetPids(); - if (this_present_pids || that_present_pids) { - if (!(this_present_pids && that_present_pids)) - return false; - if (!this.pids.equals(that.pids)) - return false; - } + boolean this_present_pid = true; + boolean that_present_pid = true; + if (this_present_pid || that_present_pid) { + if (!(this_present_pid && that_present_pid)) + return false; + if (this.pid != that.pid) + return false; + } - return true; - } + boolean this_present_data = true && this.isSetData(); + boolean that_present_data = true && that.isSetData(); + if (this_present_data || that_present_data) { + if (!(this_present_data && that_present_data)) + return false; + if (!this.data.equals(that.data)) + return false; + } - @Override - public int hashCode() { - return 0; - } + return true; + } - public int compareTo(deletePackages_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - deletePackages_args typedOther = (deletePackages_args)other; - - lastComparison = Boolean.valueOf(isSetPids()).compareTo(typedOther.isSetPids()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPids()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pids, typedOther.pids); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + boolean present_pid = true; + list.add(present_pid); + if (present_pid) + list.add(pid); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + boolean present_data = true && (isSetData()); + list.add(present_data); + if (present_data) + list.add(data); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + return list.hashCode(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("deletePackages_args("); - boolean first = true; - - sb.append("pids:"); - if (this.pids == null) { - sb.append("null"); - } else { - sb.append(this.pids); - } - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public int compareTo(setPackageData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + int lastComparison = 0; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + lastComparison = Boolean.valueOf(isSetPid()).compareTo(other.isSetPid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, other.pid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetData()).compareTo(other.isSetData()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetData()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, other.data); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - 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.getMessage()); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class deletePackages_argsStandardSchemeFactory implements SchemeFactory { - public deletePackages_argsStandardScheme getScheme() { - return new deletePackages_argsStandardScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class deletePackages_argsStandardScheme extends StandardScheme<deletePackages_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deletePackages_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: // PIDS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list274 = iprot.readListBegin(); - struct.pids = new ArrayList<Integer>(_list274.size); - for (int _i275 = 0; _i275 < _list274.size; ++_i275) - { - int _elem276; // required - _elem276 = iprot.readI32(); - struct.pids.add(_elem276); - } - iprot.readListEnd(); - } - struct.setPidsIsSet(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, deletePackages_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.pids != null) { - oprot.writeFieldBegin(PIDS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.pids.size())); - for (int _iter277 : struct.pids) - { - oprot.writeI32(_iter277); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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("setPackageData_args("); + boolean first = true; - private static class deletePackages_argsTupleSchemeFactory implements SchemeFactory { - public deletePackages_argsTupleScheme getScheme() { - return new deletePackages_argsTupleScheme(); - } - } + sb.append("pid:"); + sb.append(this.pid); + first = false; + if (!first) sb.append(", "); + sb.append("data:"); + if (this.data == null) { + sb.append("null"); + } else { + sb.append(this.data); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class deletePackages_argsTupleScheme extends TupleScheme<deletePackages_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deletePackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPids()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPids()) { - { - oprot.writeI32(struct.pids.size()); - for (int _iter278 : struct.pids) - { - oprot.writeI32(_iter278); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deletePackages_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list279 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.pids = new ArrayList<Integer>(_list279.size); - for (int _i280 = 0; _i280 < _list279.size; ++_i280) - { - int _elem281; // required - _elem281 = iprot.readI32(); - struct.pids.add(_elem281); - } - } - struct.setPidsIsSet(true); - } - } - } + 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); + } + } - public static class deletePackages_result implements org.apache.thrift.TBase<deletePackages_result, deletePackages_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deletePackages_result"); + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 setPackageData_argsStandardSchemeFactory implements SchemeFactory { + public setPackageData_argsStandardScheme getScheme() { + return new setPackageData_argsStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deletePackages_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deletePackages_resultTupleSchemeFactory()); - } + private static class setPackageData_argsStandardScheme extends StandardScheme<setPackageData_args> { + public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageData_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: // PID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // DATA + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map322 = iprot.readMapBegin(); + struct.data = new HashMap<String, String>(2 * _map322.size); + String _key323; + String _val324; + for (int _i325 = 0; _i325 < _map322.size; ++_i325) { + _key323 = iprot.readString(); + _val324 = iprot.readString(); + struct.data.put(_key323, _val324); + } + iprot.readMapEnd(); + } + struct.setDataIsSet(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(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deletePackages_result.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public deletePackages_result() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, setPackageData_args struct) throws org.apache.thrift.TException { + struct.validate(); - /** - * Performs a deep copy on <i>other</i>. - */ - public deletePackages_result(deletePackages_result other) { - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PID_FIELD_DESC); + oprot.writeI32(struct.pid); + oprot.writeFieldEnd(); + if (struct.data != null) { + oprot.writeFieldBegin(DATA_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.data.size())); + for (Map.Entry<String, String> _iter326 : struct.data.entrySet()) { + oprot.writeString(_iter326.getKey()); + oprot.writeString(_iter326.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public deletePackages_result deepCopy() { - return new deletePackages_result(this); - } + } - @Override - public void clear() { - } + private static class setPackageData_argsTupleSchemeFactory implements SchemeFactory { + public setPackageData_argsTupleScheme getScheme() { + return new setPackageData_argsTupleScheme(); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class setPackageData_argsTupleScheme extends TupleScheme<setPackageData_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setPackageData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPid()) { + optionals.set(0); + } + if (struct.isSetData()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPid()) { + oprot.writeI32(struct.pid); + } + if (struct.isSetData()) { + { + oprot.writeI32(struct.data.size()); + for (Map.Entry<String, String> _iter327 : struct.data.entrySet()) { + oprot.writeString(_iter327.getKey()); + oprot.writeString(_iter327.getValue()); + } + } + } + } - /** 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(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setPackageData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.pid = iprot.readI32(); + struct.setPidIsSet(true); + } + if (incoming.get(1)) { + { + org.apache.thrift.protocol.TMap _map328 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.data = new HashMap<String, String>(2 * _map328.size); + String _key329; + String _val330; + for (int _i331 = 0; _i331 < _map328.size; ++_i331) { + _key329 = iprot.readString(); + _val330 = iprot.readString(); + struct.data.put(_key329, _val330); + } + } + struct.setDataIsSet(true); + } + } + } - switch (field) { - } - throw new IllegalStateException(); } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deletePackages_result) - return this.equals((deletePackages_result)that); - return false; - } + public static class setPackageData_result implements org.apache.thrift.TBase<setPackageData_result, setPackageData_result._Fields>, java.io.Serializable, Cloneable, Comparable<setPackageData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageData_result"); - public boolean equals(deletePackages_result that) { - if (that == null) - return false; + private static final org.apache.thrift.protocol.TField E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short) 1); - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new setPackageData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setPackageData_resultTupleSchemeFactory()); + } - public int compareTo(deletePackages_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public PackageDoesNotExists e; // required - int lastComparison = 0; - deletePackages_result typedOther = (deletePackages_result)other; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - return 0; - } + @Override + public int describeContents() { + return 0; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public setPackageData_result(android.os.Parcel in) { + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public static final android.os.Parcelable.Creator<setPackageData_result> CREATOR = new android.os.Parcelable.Creator<setPackageData_result>() { + @Override + public setPackageData_result[] newArray(int size) { + return new setPackageData_result[size]; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public setPackageData_result createFromParcel(android.os.Parcel in) { + return new setPackageData_result(in); + } + }; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("deletePackages_result("); - boolean first = true; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + E((short) 1, "e"); - sb.append(")"); - return sb.toString(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // E + return E; + default: + return null; + } + } - 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.getMessage()); - } - } + /** + * 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; + } - private static class deletePackages_resultStandardSchemeFactory implements SchemeFactory { - public deletePackages_resultStandardScheme getScheme() { - return new deletePackages_resultStandardScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class deletePackages_resultStandardScheme extends StandardScheme<deletePackages_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deletePackages_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) { - 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, deletePackages_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class deletePackages_resultTupleSchemeFactory implements SchemeFactory { - public deletePackages_resultTupleScheme getScheme() { - return new deletePackages_resultTupleScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class deletePackages_resultTupleScheme extends TupleScheme<deletePackages_result> { + public String getFieldName() { + return _fieldName; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deletePackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deletePackages_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageData_result.class, metaDataMap); + } - } + public setPackageData_result() { + } - public static class pushToQueue_args implements org.apache.thrift.TBase<pushToQueue_args, pushToQueue_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pushToQueue_args"); + public setPackageData_result( + PackageDoesNotExists e) { + this(); + this.e = e; + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + /** + * Performs a deep copy on <i>other</i>. + */ + public setPackageData_result(setPackageData_result other) { + if (other.isSetE()) { + this.e = new PackageDoesNotExists(other.e); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pushToQueue_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pushToQueue_argsTupleSchemeFactory()); - } + public setPackageData_result deepCopy() { + return new setPackageData_result(this); + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + @Override + public void clear() { + this.e = null; + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pushToQueue_args.class, metaDataMap); - } + public PackageDoesNotExists getE() { + return this.e; + } - public pushToQueue_args() { - } + public setPackageData_result setE(PackageDoesNotExists e) { + this.e = e; + return this; + } - public pushToQueue_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + public void unsetE() { + this.e = null; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pushToQueue_args(pushToQueue_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + /** Returns true if field e is set (has been assigned a value) and false otherwise */ + public boolean isSetE() { + return this.e != null; + } - public pushToQueue_args deepCopy() { - return new pushToQueue_args(this); - } + public void setEIsSet(boolean value) { + if (!value) { + this.e = null; + } + } - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case E: + if (value == null) { + unsetE(); + } else { + setE((PackageDoesNotExists) value); + } + break; - public int getPid() { - return this.pid; - } + } + } - public pushToQueue_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case E: + return getE(); - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + } + throw new IllegalStateException(); + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + /** 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(); + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + switch (field) { + case E: + return isSetE(); + } + throw new IllegalStateException(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setPackageData_result) + return this.equals((setPackageData_result) that); + return false; } - break; - } - } + public boolean equals(setPackageData_result that) { + if (that == null) + return false; - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + boolean this_present_e = true && this.isSetE(); + boolean that_present_e = true && that.isSetE(); + if (this_present_e || that_present_e) { + if (!(this_present_e && that_present_e)) + return false; + if (!this.e.equals(that.e)) + return false; + } - } - throw new IllegalStateException(); - } + return true; + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pushToQueue_args) - return this.equals((pushToQueue_args)that); - return false; - } + boolean present_e = true && (isSetE()); + list.add(present_e); + if (present_e) + list.add(e); - public boolean equals(pushToQueue_args that) { - if (that == null) - return false; + return list.hashCode(); + } - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + @Override + public int compareTo(setPackageData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - return true; - } + int lastComparison = 0; - @Override - public int hashCode() { - return 0; - } + lastComparison = Boolean.valueOf(isSetE()).compareTo(other.isSetE()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetE()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, other.e); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public int compareTo(pushToQueue_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - pushToQueue_args typedOther = (pushToQueue_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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 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); + } - 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("setPackageData_result("); + boolean first = true; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pushToQueue_args("); - boolean first = true; + sb.append("e:"); + if (this.e == null) { + sb.append("null"); + } else { + sb.append(this.e); + } + first = false; + sb.append(")"); + return sb.toString(); + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class setPackageData_resultStandardSchemeFactory implements SchemeFactory { + public setPackageData_resultStandardScheme getScheme() { + return new setPackageData_resultStandardScheme(); + } + } - private static class pushToQueue_argsStandardSchemeFactory implements SchemeFactory { - public pushToQueue_argsStandardScheme getScheme() { - return new pushToQueue_argsStandardScheme(); - } - } + private static class setPackageData_resultStandardScheme extends StandardScheme<setPackageData_result> { - private static class pushToQueue_argsStandardScheme extends StandardScheme<pushToQueue_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pushToQueue_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, pushToQueue_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageData_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: // E + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(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(); + } - private static class pushToQueue_argsTupleSchemeFactory implements SchemeFactory { - public pushToQueue_argsTupleScheme getScheme() { - return new pushToQueue_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, setPackageData_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class pushToQueue_argsTupleScheme extends TupleScheme<pushToQueue_args> { + oprot.writeStructBegin(STRUCT_DESC); + if (struct.e != null) { + oprot.writeFieldBegin(E_FIELD_DESC); + struct.e.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pushToQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); + + private static class setPackageData_resultTupleSchemeFactory implements SchemeFactory { + public setPackageData_resultTupleScheme getScheme() { + return new setPackageData_resultTupleScheme(); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pushToQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + private static class setPackageData_resultTupleScheme extends TupleScheme<setPackageData_result> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setPackageData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetE()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetE()) { + struct.e.write(oprot); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setPackageData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.e = new PackageDoesNotExists(); + struct.e.read(iprot); + struct.setEIsSet(true); + } + } } - } + } - } + public static class deleteFinished_args implements org.apache.thrift.TBase<deleteFinished_args, deleteFinished_args._Fields>, java.io.Serializable, Cloneable, Comparable<deleteFinished_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFinished_args"); - public static class pushToQueue_result implements org.apache.thrift.TBase<pushToQueue_result, pushToQueue_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pushToQueue_result"); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pushToQueue_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pushToQueue_resultTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new deleteFinished_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deleteFinished_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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pushToQueue_result.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public pushToQueue_result() { - } + @Override + public int describeContents() { + return 0; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pushToQueue_result(pushToQueue_result other) { - } + public deleteFinished_args(android.os.Parcel in) { + } - public pushToQueue_result deepCopy() { - return new pushToQueue_result(this); - } + public static final android.os.Parcelable.Creator<deleteFinished_args> CREATOR = new android.os.Parcelable.Creator<deleteFinished_args>() { + @Override + public deleteFinished_args[] newArray(int size) { + return new deleteFinished_args[size]; + } - @Override - public void clear() { - } + @Override + public deleteFinished_args createFromParcel(android.os.Parcel in) { + return new deleteFinished_args(in); + } + }; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** 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(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pushToQueue_result) - return this.equals((pushToQueue_result)that); - return false; - } + /** + * 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; + } - public boolean equals(pushToQueue_result that) { - if (that == null) - return false; + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - return true; - } + private final short _thriftId; + private final String _fieldName; - @Override - public int hashCode() { - return 0; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public int compareTo(pushToQueue_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public short getThriftFieldId() { + return _thriftId; + } - int lastComparison = 0; - pushToQueue_result typedOther = (pushToQueue_result)other; + public String getFieldName() { + return _fieldName; + } + } - return 0; - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFinished_args.class, metaDataMap); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public deleteFinished_args() { + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public deleteFinished_args(deleteFinished_args other) { + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pushToQueue_result("); - boolean first = true; + public deleteFinished_args deepCopy() { + return new deleteFinished_args(this); + } - sb.append(")"); - return sb.toString(); - } + @Override + public void clear() { + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - 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.getMessage()); - } - } + /** 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(); + } - private static class pushToQueue_resultStandardSchemeFactory implements SchemeFactory { - public pushToQueue_resultStandardScheme getScheme() { - return new pushToQueue_resultStandardScheme(); - } - } + switch (field) { + } + throw new IllegalStateException(); + } - private static class pushToQueue_resultStandardScheme extends StandardScheme<pushToQueue_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pushToQueue_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) { - 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, pushToQueue_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteFinished_args) + return this.equals((deleteFinished_args) that); + return false; + } - } + public boolean equals(deleteFinished_args that) { + if (that == null) + return false; - private static class pushToQueue_resultTupleSchemeFactory implements SchemeFactory { - public pushToQueue_resultTupleScheme getScheme() { - return new pushToQueue_resultTupleScheme(); - } - } + return true; + } - private static class pushToQueue_resultTupleScheme extends TupleScheme<pushToQueue_result> { + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pushToQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + return list.hashCode(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pushToQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public int compareTo(deleteFinished_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - } + int lastComparison = 0; - public static class pullFromQueue_args implements org.apache.thrift.TBase<pullFromQueue_args, pullFromQueue_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pullFromQueue_args"); + return 0; + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pullFromQueue_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pullFromQueue_argsTupleSchemeFactory()); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pullFromQueue_args.class, metaDataMap); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deleteFinished_args("); + boolean first = true; - public pullFromQueue_args() { - } + sb.append(")"); + return sb.toString(); + } - public pullFromQueue_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pullFromQueue_args(pullFromQueue_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public pullFromQueue_args deepCopy() { - return new pullFromQueue_args(this); - } + 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); + } + } - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + private static class deleteFinished_argsStandardSchemeFactory implements SchemeFactory { + public deleteFinished_argsStandardScheme getScheme() { + return new deleteFinished_argsStandardScheme(); + } + } - public int getPid() { - return this.pid; - } + private static class deleteFinished_argsStandardScheme extends StandardScheme<deleteFinished_args> { - public pullFromQueue_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFinished_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(); - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, deleteFinished_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); } - break; - } - } + private static class deleteFinished_argsTupleSchemeFactory implements SchemeFactory { + public deleteFinished_argsTupleScheme getScheme() { + return new deleteFinished_argsTupleScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + private static class deleteFinished_argsTupleScheme extends TupleScheme<deleteFinished_args> { - } - throw new IllegalStateException(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deleteFinished_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deleteFinished_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pullFromQueue_args) - return this.equals((pullFromQueue_args)that); - return false; } - public boolean equals(pullFromQueue_args that) { - if (that == null) - return false; + public static class deleteFinished_result implements org.apache.thrift.TBase<deleteFinished_result, deleteFinished_result._Fields>, java.io.Serializable, Cloneable, Comparable<deleteFinished_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFinished_result"); - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + 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); - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new deleteFinished_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new deleteFinished_resultTupleSchemeFactory()); + } - public int compareTo(pullFromQueue_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - pullFromQueue_args typedOther = (pullFromQueue_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public List<Integer> success; // required - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(success); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int describeContents() { + return 0; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public deleteFinished_result(android.os.Parcel in) { + this.success = new ArrayList<Integer>(); + in.readList(this.success, deleteFinished_result.class.getClassLoader()); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pullFromQueue_args("); - boolean first = true; + public static final android.os.Parcelable.Creator<deleteFinished_result> CREATOR = new android.os.Parcelable.Creator<deleteFinished_result>() { + @Override + public deleteFinished_result[] newArray(int size) { + return new deleteFinished_result[size]; + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public deleteFinished_result createFromParcel(android.os.Parcel in) { + return new deleteFinished_result(in); + } + }; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** 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 void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class pullFromQueue_argsStandardSchemeFactory implements SchemeFactory { - public pullFromQueue_argsStandardScheme getScheme() { - return new pullFromQueue_argsStandardScheme(); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - private static class pullFromQueue_argsStandardScheme extends StandardScheme<pullFromQueue_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pullFromQueue_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, pullFromQueue_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * 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 static class pullFromQueue_argsTupleSchemeFactory implements SchemeFactory { - public pullFromQueue_argsTupleScheme getScheme() { - return new pullFromQueue_argsTupleScheme(); - } - } + private final short _thriftId; + private final String _fieldName; - private static class pullFromQueue_argsTupleScheme extends TupleScheme<pullFromQueue_args> { + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + public String getFieldName() { + return _fieldName; + } } - } - } - - } - - public static class pullFromQueue_result implements org.apache.thrift.TBase<pullFromQueue_result, pullFromQueue_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("pullFromQueue_result"); + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new pullFromQueue_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new pullFromQueue_resultTupleSchemeFactory()); - } - + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "PackageID")))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFinished_result.class, metaDataMap); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(pullFromQueue_result.class, metaDataMap); - } + public deleteFinished_result() { + } - public pullFromQueue_result() { - } + public deleteFinished_result( + List<Integer> success) { + this(); + this.success = success; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public pullFromQueue_result(pullFromQueue_result other) { - } + /** + * Performs a deep copy on <i>other</i>. + */ + public deleteFinished_result(deleteFinished_result other) { + if (other.isSetSuccess()) { + List<Integer> __this__success = new ArrayList<Integer>(other.success.size()); + for (Integer other_element : other.success) { + __this__success.add(other_element); + } + this.success = __this__success; + } + } - public pullFromQueue_result deepCopy() { - return new pullFromQueue_result(this); - } + public deleteFinished_result deepCopy() { + return new deleteFinished_result(this); + } - @Override - public void clear() { - } + @Override + public void clear() { + this.success = null; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public java.util.Iterator<Integer> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - /** 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(); - } + public void addToSuccess(int elem) { + if (this.success == null) { + this.success = new ArrayList<Integer>(); + } + this.success.add(elem); + } - switch (field) { - } - throw new IllegalStateException(); - } + public List<Integer> getSuccess() { + return this.success; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof pullFromQueue_result) - return this.equals((pullFromQueue_result)that); - return false; - } + public deleteFinished_result setSuccess(List<Integer> success) { + this.success = success; + return this; + } - public boolean equals(pullFromQueue_result that) { - if (that == null) - return false; + public void unsetSuccess() { + this.success = null; + } - return true; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - @Override - public int hashCode() { - return 0; - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public int compareTo(pullFromQueue_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<Integer>) value); + } + break; - int lastComparison = 0; - pullFromQueue_result typedOther = (pullFromQueue_result)other; + } + } - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** 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(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("pullFromQueue_result("); - boolean first = true; + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof deleteFinished_result) + return this.equals((deleteFinished_result) that); + return false; + } - sb.append(")"); - return sb.toString(); - } + public boolean equals(deleteFinished_result that) { + if (that == null) + return false; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return true; + } - 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.getMessage()); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class pullFromQueue_resultStandardSchemeFactory implements SchemeFactory { - public pullFromQueue_resultStandardScheme getScheme() { - return new pullFromQueue_resultStandardScheme(); - } - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - private static class pullFromQueue_resultStandardScheme extends StandardScheme<pullFromQueue_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, pullFromQueue_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) { - 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, pullFromQueue_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return list.hashCode(); + } - } + @Override + public int compareTo(deleteFinished_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class pullFromQueue_resultTupleSchemeFactory implements SchemeFactory { - public pullFromQueue_resultTupleScheme getScheme() { - return new pullFromQueue_resultTupleScheme(); - } - } + int lastComparison = 0; - private static class pullFromQueue_resultTupleScheme extends TupleScheme<pullFromQueue_result> { + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, pullFromQueue_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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); + } - public static class restartPackage_args implements org.apache.thrift.TBase<restartPackage_args, restartPackage_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartPackage_args"); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("deleteFinished_result("); + boolean first = true; - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartPackage_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartPackage_argsTupleSchemeFactory()); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartPackage_args.class, metaDataMap); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public restartPackage_args() { - } + private static class deleteFinished_resultStandardSchemeFactory implements SchemeFactory { + public deleteFinished_resultStandardScheme getScheme() { + return new deleteFinished_resultStandardScheme(); + } + } - public restartPackage_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + private static class deleteFinished_resultStandardScheme extends StandardScheme<deleteFinished_result> { - /** - * Performs a deep copy on <i>other</i>. - */ - public restartPackage_args(restartPackage_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFinished_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 _list332 = iprot.readListBegin(); + struct.success = new ArrayList<Integer>(_list332.size); + int _elem333; + for (int _i334 = 0; _i334 < _list332.size; ++_i334) { + _elem333 = iprot.readI32(); + struct.success.add(_elem333); + } + iprot.readListEnd(); + } + 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(); - public restartPackage_args deepCopy() { - return new restartPackage_args(this); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, deleteFinished_result struct) throws org.apache.thrift.TException { + struct.validate(); - public int getPid() { - return this.pid; - } + 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.I32, struct.success.size())); + for (int _iter335 : struct.success) { + oprot.writeI32(_iter335); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public restartPackage_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + private static class deleteFinished_resultTupleSchemeFactory implements SchemeFactory { + public deleteFinished_resultTupleScheme getScheme() { + return new deleteFinished_resultTupleScheme(); + } + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + private static class deleteFinished_resultTupleScheme extends TupleScheme<deleteFinished_result> { - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, deleteFinished_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (int _iter336 : struct.success) { + oprot.writeI32(_iter336); + } + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, deleteFinished_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list337 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); + struct.success = new ArrayList<Integer>(_list337.size); + int _elem338; + for (int _i339 = 0; _i339 < _list337.size; ++_i339) { + _elem338 = iprot.readI32(); + struct.success.add(_elem338); + } + } + struct.setSuccessIsSet(true); + } + } } - break; - } } - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + public static class restartFailed_args implements org.apache.thrift.TBase<restartFailed_args, restartFailed_args._Fields>, java.io.Serializable, Cloneable, Comparable<restartFailed_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFailed_args"); - } - 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartPackage_args) - return this.equals((restartPackage_args)that); - return false; - } + static { + schemes.put(StandardScheme.class, new restartFailed_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartFailed_argsTupleSchemeFactory()); + } - public boolean equals(restartPackage_args that) { - if (that == null) - return false; - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - return true; - } + @Override + public int describeContents() { + return 0; + } - @Override - public int hashCode() { - return 0; - } + public restartFailed_args(android.os.Parcel in) { + } - public int compareTo(restartPackage_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - restartPackage_args typedOther = (restartPackage_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public static final android.os.Parcelable.Creator<restartFailed_args> CREATOR = new android.os.Parcelable.Creator<restartFailed_args>() { + @Override + public restartFailed_args[] newArray(int size) { + return new restartFailed_args[size]; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public restartFailed_args createFromParcel(android.os.Parcel in) { + return new restartFailed_args(in); + } + }; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartPackage_args("); - boolean first = true; + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** + * 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; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private final short _thriftId; + private final String _fieldName; - private static class restartPackage_argsStandardSchemeFactory implements SchemeFactory { - public restartPackage_argsStandardScheme getScheme() { - return new restartPackage_argsStandardScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class restartPackage_argsStandardScheme extends StandardScheme<restartPackage_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartPackage_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, restartPackage_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public short getThriftFieldId() { + return _thriftId; + } - } + public String getFieldName() { + return _fieldName; + } + } - private static class restartPackage_argsTupleSchemeFactory implements SchemeFactory { - public restartPackage_argsTupleScheme getScheme() { - return new restartPackage_argsTupleScheme(); - } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class restartPackage_argsTupleScheme extends TupleScheme<restartPackage_args> { + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFailed_args.class, metaDataMap); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); + public restartFailed_args() { } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); + + /** + * Performs a deep copy on <i>other</i>. + */ + public restartFailed_args(restartFailed_args other) { } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + public restartFailed_args deepCopy() { + return new restartFailed_args(this); } - } - } - } + @Override + public void clear() { + } - public static class restartPackage_result implements org.apache.thrift.TBase<restartPackage_result, restartPackage_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartPackage_result"); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartPackage_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartPackage_resultTupleSchemeFactory()); - } + /** 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) { + } + throw new IllegalStateException(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartPackage_result.class, metaDataMap); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartFailed_args) + return this.equals((restartFailed_args) that); + return false; + } - public restartPackage_result() { - } + public boolean equals(restartFailed_args that) { + if (that == null) + return false; - /** - * Performs a deep copy on <i>other</i>. - */ - public restartPackage_result(restartPackage_result other) { - } + return true; + } - public restartPackage_result deepCopy() { - return new restartPackage_result(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - } + return list.hashCode(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int compareTo(restartFailed_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + int lastComparison = 0; - /** 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(); - } + return 0; + } - switch (field) { - } - throw new IllegalStateException(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartPackage_result) - return this.equals((restartPackage_result)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public boolean equals(restartPackage_result that) { - if (that == null) - return false; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - return true; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartFailed_args("); + boolean first = true; - @Override - public int hashCode() { - return 0; - } + sb.append(")"); + return sb.toString(); + } - public int compareTo(restartPackage_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - int lastComparison = 0; - restartPackage_result typedOther = (restartPackage_result)other; + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - return 0; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class restartFailed_argsStandardSchemeFactory implements SchemeFactory { + public restartFailed_argsStandardScheme getScheme() { + return new restartFailed_argsStandardScheme(); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class restartFailed_argsStandardScheme extends StandardScheme<restartFailed_args> { - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, restartFailed_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(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartPackage_result("); - boolean first = true; + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - sb.append(")"); - return sb.toString(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartFailed_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + } - 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.getMessage()); - } - } + private static class restartFailed_argsTupleSchemeFactory implements SchemeFactory { + public restartFailed_argsTupleScheme getScheme() { + return new restartFailed_argsTupleScheme(); + } + } - private static class restartPackage_resultStandardSchemeFactory implements SchemeFactory { - public restartPackage_resultStandardScheme getScheme() { - return new restartPackage_resultStandardScheme(); - } - } + private static class restartFailed_argsTupleScheme extends TupleScheme<restartFailed_args> { - private static class restartPackage_resultStandardScheme extends StandardScheme<restartPackage_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartPackage_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) { - 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, restartPackage_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartFailed_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartFailed_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static class restartPackage_resultTupleSchemeFactory implements SchemeFactory { - public restartPackage_resultTupleScheme getScheme() { - return new restartPackage_resultTupleScheme(); - } } - private static class restartPackage_resultTupleScheme extends TupleScheme<restartPackage_result> { + public static class restartFailed_result implements org.apache.thrift.TBase<restartFailed_result, restartFailed_result._Fields>, java.io.Serializable, Cloneable, Comparable<restartFailed_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFailed_result"); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - } + static { + schemes.put(StandardScheme.class, new restartFailed_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new restartFailed_resultTupleSchemeFactory()); + } - public static class restartFile_args implements org.apache.thrift.TBase<restartFile_args, restartFile_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFile_args"); - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartFile_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartFile_argsTupleSchemeFactory()); - } + @Override + public int describeContents() { + return 0; + } - public int fid; // 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 { - FID((short)1, "fid"); - - 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: // FID - return FID; - 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; - } - } + public restartFailed_result(android.os.Parcel in) { + } - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFile_args.class, metaDataMap); - } + public static final android.os.Parcelable.Creator<restartFailed_result> CREATOR = new android.os.Parcelable.Creator<restartFailed_result>() { + @Override + public restartFailed_result[] newArray(int size) { + return new restartFailed_result[size]; + } - public restartFile_args() { - } + @Override + public restartFailed_result createFromParcel(android.os.Parcel in) { + return new restartFailed_result(in); + } + }; - public restartFile_args( - int fid) - { - this(); - this.fid = fid; - setFidIsSet(true); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - /** - * Performs a deep copy on <i>other</i>. - */ - public restartFile_args(restartFile_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public restartFile_args deepCopy() { - return new restartFile_args(this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public int getFid() { - return this.fid; - } + /** + * 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; + } - public restartFile_args setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } + private final short _thriftId; + private final String _fieldName; - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } + public short getThriftFieldId() { + return _thriftId; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); + public String getFieldName() { + return _fieldName; + } } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFailed_result.class, metaDataMap); + } - /** 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 FID: - return isSetFid(); - } - throw new IllegalStateException(); - } + public restartFailed_result() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartFile_args) - return this.equals((restartFile_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public restartFailed_result(restartFailed_result other) { + } - public boolean equals(restartFile_args that) { - if (that == null) - return false; + public restartFailed_result deepCopy() { + return new restartFailed_result(this); + } - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; - } + @Override + public void clear() { + } - return true; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - @Override - public int hashCode() { - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public int compareTo(restartFile_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - restartFile_args typedOther = (restartFile_args)other; - - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** 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(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + switch (field) { + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof restartFailed_result) + return this.equals((restartFailed_result) that); + return false; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public boolean equals(restartFailed_result that) { + if (that == null) + return false; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartFile_args("); - boolean first = true; + return true; + } - sb.append("fid:"); - sb.append(this.fid); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(restartFailed_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + int lastComparison = 0; - private static class restartFile_argsStandardSchemeFactory implements SchemeFactory { - public restartFile_argsStandardScheme getScheme() { - return new restartFile_argsStandardScheme(); - } - } + return 0; + } - private static class restartFile_argsStandardScheme extends StandardScheme<restartFile_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartFile_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: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(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, restartFile_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class restartFile_argsTupleSchemeFactory implements SchemeFactory { - public restartFile_argsTupleScheme getScheme() { - return new restartFile_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class restartFile_argsTupleScheme extends TupleScheme<restartFile_args> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("restartFailed_result("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartFile_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); + sb.append(")"); + return sb.toString(); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartFile_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); + 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); + } + } - public static class restartFile_result implements org.apache.thrift.TBase<restartFile_result, restartFile_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFile_result"); + 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 restartFailed_resultStandardSchemeFactory implements SchemeFactory { + public restartFailed_resultStandardScheme getScheme() { + return new restartFailed_resultStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartFile_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartFile_resultTupleSchemeFactory()); - } + private static class restartFailed_resultStandardScheme extends StandardScheme<restartFailed_result> { + public void read(org.apache.thrift.protocol.TProtocol iprot, restartFailed_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFile_result.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public restartFile_result() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, restartFailed_result struct) throws org.apache.thrift.TException { + struct.validate(); - /** - * Performs a deep copy on <i>other</i>. - */ - public restartFile_result(restartFile_result other) { - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public restartFile_result deepCopy() { - return new restartFile_result(this); - } + } - @Override - public void clear() { - } + private static class restartFailed_resultTupleSchemeFactory implements SchemeFactory { + public restartFailed_resultTupleScheme getScheme() { + return new restartFailed_resultTupleScheme(); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class restartFailed_resultTupleScheme extends TupleScheme<restartFailed_result> { - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, restartFailed_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - /** 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(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, restartFailed_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - switch (field) { - } - throw new IllegalStateException(); } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartFile_result) - return this.equals((restartFile_result)that); - return false; - } + public static class getEvents_args implements org.apache.thrift.TBase<getEvents_args, getEvents_args._Fields>, java.io.Serializable, Cloneable, Comparable<getEvents_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getEvents_args"); - public boolean equals(restartFile_result that) { - if (that == null) - return false; + private static final org.apache.thrift.protocol.TField UUID_FIELD_DESC = new org.apache.thrift.protocol.TField("uuid", org.apache.thrift.protocol.TType.STRING, (short) 1); - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new getEvents_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getEvents_argsTupleSchemeFactory()); + } - public int compareTo(restartFile_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public String uuid; // required - int lastComparison = 0; - restartFile_result typedOther = (restartFile_result)other; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(uuid); + } - return 0; - } + @Override + public int describeContents() { + return 0; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public getEvents_args(android.os.Parcel in) { + this.uuid = in.readString(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public static final android.os.Parcelable.Creator<getEvents_args> CREATOR = new android.os.Parcelable.Creator<getEvents_args>() { + @Override + public getEvents_args[] newArray(int size) { + return new getEvents_args[size]; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public getEvents_args createFromParcel(android.os.Parcel in) { + return new getEvents_args(in); + } + }; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartFile_result("); - boolean first = true; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + UUID((short) 1, "uuid"); - sb.append(")"); - return sb.toString(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // UUID + return UUID; + default: + return null; + } + } - 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.getMessage()); - } - } + /** + * 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; + } - private static class restartFile_resultStandardSchemeFactory implements SchemeFactory { - public restartFile_resultStandardScheme getScheme() { - return new restartFile_resultStandardScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class restartFile_resultStandardScheme extends StandardScheme<restartFile_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartFile_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) { - 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, restartFile_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private final short _thriftId; + private final String _fieldName; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class restartFile_resultTupleSchemeFactory implements SchemeFactory { - public restartFile_resultTupleScheme getScheme() { - return new restartFile_resultTupleScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class restartFile_resultTupleScheme extends TupleScheme<restartFile_result> { + public String getFieldName() { + return _fieldName; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartFile_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartFile_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.UUID, new org.apache.thrift.meta_data.FieldMetaData("uuid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getEvents_args.class, metaDataMap); + } - } + public getEvents_args() { + } - public static class recheckPackage_args implements org.apache.thrift.TBase<recheckPackage_args, recheckPackage_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("recheckPackage_args"); + public getEvents_args( + String uuid) { + this(); + this.uuid = uuid; + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); + /** + * Performs a deep copy on <i>other</i>. + */ + public getEvents_args(getEvents_args other) { + if (other.isSetUuid()) { + this.uuid = other.uuid; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new recheckPackage_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new recheckPackage_argsTupleSchemeFactory()); - } + public getEvents_args deepCopy() { + return new getEvents_args(this); + } - public int pid; // 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 { - PID((short)1, "pid"); - - 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: // PID - return PID; - 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; - } - } + @Override + public void clear() { + this.uuid = null; + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(recheckPackage_args.class, metaDataMap); - } + public String getUuid() { + return this.uuid; + } - public recheckPackage_args() { - } + public getEvents_args setUuid(String uuid) { + this.uuid = uuid; + return this; + } - public recheckPackage_args( - int pid) - { - this(); - this.pid = pid; - setPidIsSet(true); - } + public void unsetUuid() { + this.uuid = null; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public recheckPackage_args(recheckPackage_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - } + /** Returns true if field uuid is set (has been assigned a value) and false otherwise */ + public boolean isSetUuid() { + return this.uuid != null; + } - public recheckPackage_args deepCopy() { - return new recheckPackage_args(this); - } + public void setUuidIsSet(boolean value) { + if (!value) { + this.uuid = null; + } + } - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case UUID: + if (value == null) { + unsetUuid(); + } else { + setUuid((String) value); + } + break; - public int getPid() { - return this.pid; - } + } + } - public recheckPackage_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case UUID: + return getUuid(); - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + } + throw new IllegalStateException(); + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + /** 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(); + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + switch (field) { + case UUID: + return isSetUuid(); + } + throw new IllegalStateException(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getEvents_args) + return this.equals((getEvents_args) that); + return false; } - break; - } - } + public boolean equals(getEvents_args that) { + if (that == null) + return false; - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + boolean this_present_uuid = true && this.isSetUuid(); + boolean that_present_uuid = true && that.isSetUuid(); + if (this_present_uuid || that_present_uuid) { + if (!(this_present_uuid && that_present_uuid)) + return false; + if (!this.uuid.equals(that.uuid)) + return false; + } - } - throw new IllegalStateException(); - } + return true; + } - /** 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 PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof recheckPackage_args) - return this.equals((recheckPackage_args)that); - return false; - } + boolean present_uuid = true && (isSetUuid()); + list.add(present_uuid); + if (present_uuid) + list.add(uuid); - public boolean equals(recheckPackage_args that) { - if (that == null) - return false; + return list.hashCode(); + } - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } + @Override + public int compareTo(getEvents_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - return true; - } + int lastComparison = 0; - @Override - public int hashCode() { - return 0; - } + lastComparison = Boolean.valueOf(isSetUuid()).compareTo(other.isSetUuid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetUuid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.uuid, other.uuid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public int compareTo(recheckPackage_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - recheckPackage_args typedOther = (recheckPackage_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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 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); + } - 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("getEvents_args("); + boolean first = true; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("recheckPackage_args("); - boolean first = true; + sb.append("uuid:"); + if (this.uuid == null) { + sb.append("null"); + } else { + sb.append(this.uuid); + } + first = false; + sb.append(")"); + return sb.toString(); + } - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class getEvents_argsStandardSchemeFactory implements SchemeFactory { + public getEvents_argsStandardScheme getScheme() { + return new getEvents_argsStandardScheme(); + } + } - private static class recheckPackage_argsStandardSchemeFactory implements SchemeFactory { - public recheckPackage_argsStandardScheme getScheme() { - return new recheckPackage_argsStandardScheme(); - } - } + private static class getEvents_argsStandardScheme extends StandardScheme<getEvents_args> { - private static class recheckPackage_argsStandardScheme extends StandardScheme<recheckPackage_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, recheckPackage_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, recheckPackage_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getEvents_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: // UUID + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.uuid = iprot.readString(); + struct.setUuidIsSet(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(); + } - private static class recheckPackage_argsTupleSchemeFactory implements SchemeFactory { - public recheckPackage_argsTupleScheme getScheme() { - return new recheckPackage_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getEvents_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class recheckPackage_argsTupleScheme extends TupleScheme<recheckPackage_args> { + oprot.writeStructBegin(STRUCT_DESC); + if (struct.uuid != null) { + oprot.writeFieldBegin(UUID_FIELD_DESC); + oprot.writeString(struct.uuid); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, recheckPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, recheckPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + private static class getEvents_argsTupleSchemeFactory implements SchemeFactory { + public getEvents_argsTupleScheme getScheme() { + return new getEvents_argsTupleScheme(); + } } - } - } - } + private static class getEvents_argsTupleScheme extends TupleScheme<getEvents_args> { - public static class recheckPackage_result implements org.apache.thrift.TBase<recheckPackage_result, recheckPackage_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("recheckPackage_result"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getEvents_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUuid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetUuid()) { + oprot.writeString(struct.uuid); + } + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getEvents_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.uuid = iprot.readString(); + struct.setUuidIsSet(true); + } + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new recheckPackage_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new recheckPackage_resultTupleSchemeFactory()); } + public static class getEvents_result implements org.apache.thrift.TBase<getEvents_result, getEvents_result._Fields>, java.io.Serializable, Cloneable, Comparable<getEvents_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getEvents_result"); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(recheckPackage_result.class, metaDataMap); - } + 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); - public recheckPackage_result() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** - * Performs a deep copy on <i>other</i>. - */ - public recheckPackage_result(recheckPackage_result other) { - } + static { + schemes.put(StandardScheme.class, new getEvents_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getEvents_resultTupleSchemeFactory()); + } - public recheckPackage_result deepCopy() { - return new recheckPackage_result(this); - } + public List<EventInfo> success; // required - @Override - public void clear() { - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int describeContents() { + return 0; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public getEvents_result(android.os.Parcel in) { + this.success = new ArrayList<EventInfo>(); + in.readTypedList(this.success, EventInfo.CREATOR); + } - /** 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(); - } + public static final android.os.Parcelable.Creator<getEvents_result> CREATOR = new android.os.Parcelable.Creator<getEvents_result>() { + @Override + public getEvents_result[] newArray(int size) { + return new getEvents_result[size]; + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public getEvents_result createFromParcel(android.os.Parcel in) { + return new getEvents_result(in); + } + }; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof recheckPackage_result) - return this.equals((recheckPackage_result)that); - return false; - } + /** 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"); - public boolean equals(recheckPackage_result that) { - if (that == null) - return false; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - return true; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public int hashCode() { - return 0; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + 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; + } - public int compareTo(recheckPackage_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - int lastComparison = 0; - recheckPackage_result typedOther = (recheckPackage_result)other; + private final short _thriftId; + private final String _fieldName; - return 0; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public short getThriftFieldId() { + return _thriftId; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public String getFieldName() { + return _fieldName; + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("recheckPackage_result("); - boolean first = true; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, EventInfo.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getEvents_result.class, metaDataMap); + } - sb.append(")"); - return sb.toString(); - } + public getEvents_result() { + } + + public getEvents_result( + List<EventInfo> success) { + this(); + this.success = success; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public getEvents_result(getEvents_result other) { + if (other.isSetSuccess()) { + List<EventInfo> __this__success = new ArrayList<EventInfo>(other.success.size()); + for (EventInfo other_element : other.success) { + __this__success.add(new EventInfo(other_element)); + } + this.success = __this__success; + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public getEvents_result deepCopy() { + return new getEvents_result(this); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void clear() { + this.success = null; + } - 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.getMessage()); - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - private static class recheckPackage_resultStandardSchemeFactory implements SchemeFactory { - public recheckPackage_resultStandardScheme getScheme() { - return new recheckPackage_resultStandardScheme(); - } - } + public java.util.Iterator<EventInfo> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - private static class recheckPackage_resultStandardScheme extends StandardScheme<recheckPackage_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, recheckPackage_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) { - 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, recheckPackage_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void addToSuccess(EventInfo elem) { + if (this.success == null) { + this.success = new ArrayList<EventInfo>(); + } + this.success.add(elem); + } - } + public List<EventInfo> getSuccess() { + return this.success; + } - private static class recheckPackage_resultTupleSchemeFactory implements SchemeFactory { - public recheckPackage_resultTupleScheme getScheme() { - return new recheckPackage_resultTupleScheme(); - } - } + public getEvents_result setSuccess(List<EventInfo> success) { + this.success = success; + return this; + } - private static class recheckPackage_resultTupleScheme extends TupleScheme<recheckPackage_result> { + public void unsetSuccess() { + this.success = null; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, recheckPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, recheckPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<EventInfo>) value); + } + break; - public static class stopAllDownloads_args implements org.apache.thrift.TBase<stopAllDownloads_args, stopAllDownloads_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopAllDownloads_args"); + } + } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new stopAllDownloads_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new stopAllDownloads_argsTupleSchemeFactory()); - } + } + 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(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopAllDownloads_args.class, metaDataMap); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public stopAllDownloads_args() { - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getEvents_result) + return this.equals((getEvents_result) that); + return false; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public stopAllDownloads_args(stopAllDownloads_args other) { - } + public boolean equals(getEvents_result that) { + if (that == null) + return false; - public stopAllDownloads_args deepCopy() { - return new stopAllDownloads_args(this); - } + 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; + } - @Override - public void clear() { - } + return true; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - /** 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(); - } + return list.hashCode(); + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int compareTo(getEvents_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof stopAllDownloads_args) - return this.equals((stopAllDownloads_args)that); - return false; - } + int lastComparison = 0; - public boolean equals(stopAllDownloads_args that) { - if (that == null) - return false; + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - return true; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int compareTo(stopAllDownloads_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - int lastComparison = 0; - stopAllDownloads_args typedOther = (stopAllDownloads_args)other; + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getEvents_result("); + boolean first = true; - return 0; - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("stopAllDownloads_args("); - boolean first = true; + private static class getEvents_resultStandardSchemeFactory implements SchemeFactory { + public getEvents_resultStandardScheme getScheme() { + return new getEvents_resultStandardScheme(); + } + } - sb.append(")"); - return sb.toString(); - } + private static class getEvents_resultStandardScheme extends StandardScheme<getEvents_result> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getEvents_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 _list340 = iprot.readListBegin(); + struct.success = new ArrayList<EventInfo>(_list340.size); + EventInfo _elem341; + for (int _i342 = 0; _i342 < _list340.size; ++_i342) { + _elem341 = new EventInfo(); + _elem341.read(iprot); + struct.success.add(_elem341); + } + iprot.readListEnd(); + } + 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(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getEvents_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class stopAllDownloads_argsStandardSchemeFactory implements SchemeFactory { - public stopAllDownloads_argsStandardScheme getScheme() { - return new stopAllDownloads_argsStandardScheme(); - } - } + 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 (EventInfo _iter343 : struct.success) { + _iter343.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class stopAllDownloads_argsStandardScheme extends StandardScheme<stopAllDownloads_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, stopAllDownloads_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, stopAllDownloads_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } - } + private static class getEvents_resultTupleSchemeFactory implements SchemeFactory { + public getEvents_resultTupleScheme getScheme() { + return new getEvents_resultTupleScheme(); + } + } - private static class stopAllDownloads_argsTupleSchemeFactory implements SchemeFactory { - public stopAllDownloads_argsTupleScheme getScheme() { - return new stopAllDownloads_argsTupleScheme(); - } - } + private static class getEvents_resultTupleScheme extends TupleScheme<getEvents_result> { - private static class stopAllDownloads_argsTupleScheme extends TupleScheme<stopAllDownloads_args> { + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getEvents_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (EventInfo _iter344 : struct.success) { + _iter344.write(oprot); + } + } + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getEvents_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list345 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<EventInfo>(_list345.size); + EventInfo _elem346; + for (int _i347 = 0; _i347 < _list345.size; ++_i347) { + _elem346 = new EventInfo(); + _elem346.read(iprot); + struct.success.add(_elem346); + } + } + struct.setSuccessIsSet(true); + } + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } } - } + public static class getAccounts_args implements org.apache.thrift.TBase<getAccounts_args, getAccounts_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAccounts_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccounts_args"); - public static class stopAllDownloads_result implements org.apache.thrift.TBase<stopAllDownloads_result, stopAllDownloads_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopAllDownloads_result"); + private static final org.apache.thrift.protocol.TField REFRESH_FIELD_DESC = new org.apache.thrift.protocol.TField("refresh", org.apache.thrift.protocol.TType.BOOL, (short) 1); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new stopAllDownloads_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new stopAllDownloads_resultTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new getAccounts_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAccounts_argsTupleSchemeFactory()); + } + public boolean refresh; // 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 { -; - - 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopAllDownloads_result.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public stopAllDownloads_result() { - } + out.writeInt(refresh ? 1 : 0); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public stopAllDownloads_result(stopAllDownloads_result other) { - } + @Override + public int describeContents() { + return 0; + } - public stopAllDownloads_result deepCopy() { - return new stopAllDownloads_result(this); - } + public getAccounts_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - @Override - public void clear() { - } + this.refresh = (in.readInt() == 1); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public static final android.os.Parcelable.Creator<getAccounts_args> CREATOR = new android.os.Parcelable.Creator<getAccounts_args>() { + @Override + public getAccounts_args[] newArray(int size) { + return new getAccounts_args[size]; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public getAccounts_args createFromParcel(android.os.Parcel in) { + return new getAccounts_args(in); + } + }; - /** 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(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + REFRESH((short) 1, "refresh"); - switch (field) { - } - throw new IllegalStateException(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof stopAllDownloads_result) - return this.equals((stopAllDownloads_result)that); - return false; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public boolean equals(stopAllDownloads_result that) { - if (that == null) - return false; + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // REFRESH + return REFRESH; + default: + return null; + } + } - return true; - } + /** + * 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; + } - @Override - public int hashCode() { - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public int compareTo(stopAllDownloads_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + private final short _thriftId; + private final String _fieldName; - int lastComparison = 0; - stopAllDownloads_result typedOther = (stopAllDownloads_result)other; + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - return 0; - } + public short getThriftFieldId() { + return _thriftId; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public String getFieldName() { + return _fieldName; + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + // isset id assignments + private static final int __REFRESH_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.REFRESH, new org.apache.thrift.meta_data.FieldMetaData("refresh", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccounts_args.class, metaDataMap); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("stopAllDownloads_result("); - boolean first = true; + public getAccounts_args() { + } - sb.append(")"); - return sb.toString(); - } + public getAccounts_args( + boolean refresh) { + this(); + this.refresh = refresh; + setRefreshIsSet(true); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAccounts_args(getAccounts_args other) { + __isset_bitfield = other.__isset_bitfield; + this.refresh = other.refresh; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public getAccounts_args deepCopy() { + return new getAccounts_args(this); + } - 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.getMessage()); - } - } + @Override + public void clear() { + setRefreshIsSet(false); + this.refresh = false; + } - private static class stopAllDownloads_resultStandardSchemeFactory implements SchemeFactory { - public stopAllDownloads_resultStandardScheme getScheme() { - return new stopAllDownloads_resultStandardScheme(); - } - } + public boolean isRefresh() { + return this.refresh; + } - private static class stopAllDownloads_resultStandardScheme extends StandardScheme<stopAllDownloads_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, stopAllDownloads_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) { - 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, stopAllDownloads_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public getAccounts_args setRefresh(boolean refresh) { + this.refresh = refresh; + setRefreshIsSet(true); + return this; + } - } + public void unsetRefresh() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __REFRESH_ISSET_ID); + } - private static class stopAllDownloads_resultTupleSchemeFactory implements SchemeFactory { - public stopAllDownloads_resultTupleScheme getScheme() { - return new stopAllDownloads_resultTupleScheme(); - } - } + /** Returns true if field refresh is set (has been assigned a value) and false otherwise */ + public boolean isSetRefresh() { + return EncodingUtils.testBit(__isset_bitfield, __REFRESH_ISSET_ID); + } - private static class stopAllDownloads_resultTupleScheme extends TupleScheme<stopAllDownloads_result> { + public void setRefreshIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __REFRESH_ISSET_ID, value); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case REFRESH: + if (value == null) { + unsetRefresh(); + } else { + setRefresh((Boolean) value); + } + break; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, stopAllDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case REFRESH: + return isRefresh(); - public static class stopDownloads_args implements org.apache.thrift.TBase<stopDownloads_args, stopDownloads_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopDownloads_args"); + } + throw new IllegalStateException(); + } - private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short)1); + /** 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new stopDownloads_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new stopDownloads_argsTupleSchemeFactory()); - } + switch (field) { + case REFRESH: + return isSetRefresh(); + } + throw new IllegalStateException(); + } - public List<Integer> fids; // 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 { - FIDS((short)1, "fids"); - - 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: // FIDS - return FIDS; - 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; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAccounts_args) + return this.equals((getAccounts_args) that); + return false; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32 , "FileID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopDownloads_args.class, metaDataMap); - } + public boolean equals(getAccounts_args that) { + if (that == null) + return false; - public stopDownloads_args() { - } + boolean this_present_refresh = true; + boolean that_present_refresh = true; + if (this_present_refresh || that_present_refresh) { + if (!(this_present_refresh && that_present_refresh)) + return false; + if (this.refresh != that.refresh) + return false; + } - public stopDownloads_args( - List<Integer> fids) - { - this(); - this.fids = fids; - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public stopDownloads_args(stopDownloads_args other) { - if (other.isSetFids()) { - List<Integer> __this__fids = new ArrayList<Integer>(); - for (Integer other_element : other.fids) { - __this__fids.add(other_element); - } - this.fids = __this__fids; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public stopDownloads_args deepCopy() { - return new stopDownloads_args(this); - } + boolean present_refresh = true; + list.add(present_refresh); + if (present_refresh) + list.add(refresh); - @Override - public void clear() { - this.fids = null; - } + return list.hashCode(); + } - public int getFidsSize() { - return (this.fids == null) ? 0 : this.fids.size(); - } + @Override + public int compareTo(getAccounts_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public java.util.Iterator<Integer> getFidsIterator() { - return (this.fids == null) ? null : this.fids.iterator(); - } + int lastComparison = 0; - public void addToFids(int elem) { - if (this.fids == null) { - this.fids = new ArrayList<Integer>(); - } - this.fids.add(elem); - } + lastComparison = Boolean.valueOf(isSetRefresh()).compareTo(other.isSetRefresh()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRefresh()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.refresh, other.refresh); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public List<Integer> getFids() { - return this.fids; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public stopDownloads_args setFids(List<Integer> fids) { - this.fids = fids; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void unsetFids() { - this.fids = null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - /** Returns true if field fids is set (has been assigned a value) and false otherwise */ - public boolean isSetFids() { - return this.fids != null; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAccounts_args("); + boolean first = true; - public void setFidsIsSet(boolean value) { - if (!value) { - this.fids = null; - } - } + sb.append("refresh:"); + sb.append(this.refresh); + first = false; + sb.append(")"); + return sb.toString(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FIDS: - if (value == null) { - unsetFids(); - } else { - setFids((List<Integer>)value); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - break; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - case FIDS: - return getFids(); + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - } - throw new IllegalStateException(); - } + private static class getAccounts_argsStandardSchemeFactory implements SchemeFactory { + public getAccounts_argsStandardScheme getScheme() { + return new getAccounts_argsStandardScheme(); + } + } - /** 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 FIDS: - return isSetFids(); - } - throw new IllegalStateException(); - } + private static class getAccounts_argsStandardScheme extends StandardScheme<getAccounts_args> { - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof stopDownloads_args) - return this.equals((stopDownloads_args)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAccounts_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: // REFRESH + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.refresh = iprot.readBool(); + struct.setRefreshIsSet(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(); - public boolean equals(stopDownloads_args that) { - if (that == null) - return false; + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - boolean this_present_fids = true && this.isSetFids(); - boolean that_present_fids = true && that.isSetFids(); - if (this_present_fids || that_present_fids) { - if (!(this_present_fids && that_present_fids)) - return false; - if (!this.fids.equals(that.fids)) - return false; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAccounts_args struct) throws org.apache.thrift.TException { + struct.validate(); - return true; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(REFRESH_FIELD_DESC); + oprot.writeBool(struct.refresh); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public int hashCode() { - return 0; - } + } - public int compareTo(stopDownloads_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - stopDownloads_args typedOther = (stopDownloads_args)other; - - lastComparison = Boolean.valueOf(isSetFids()).compareTo(typedOther.isSetFids()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFids()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, typedOther.fids); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static class getAccounts_argsTupleSchemeFactory implements SchemeFactory { + public getAccounts_argsTupleScheme getScheme() { + return new getAccounts_argsTupleScheme(); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class getAccounts_argsTupleScheme extends TupleScheme<getAccounts_args> { - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAccounts_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetRefresh()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetRefresh()) { + oprot.writeBool(struct.refresh); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAccounts_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.refresh = iprot.readBool(); + struct.setRefreshIsSet(true); + } + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("stopDownloads_args("); - boolean first = true; - - sb.append("fids:"); - if (this.fids == null) { - sb.append("null"); - } else { - sb.append(this.fids); - } - first = false; - sb.append(")"); - return sb.toString(); } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public static class getAccounts_result implements org.apache.thrift.TBase<getAccounts_result, getAccounts_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAccounts_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccounts_result"); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class stopDownloads_argsStandardSchemeFactory implements SchemeFactory { - public stopDownloads_argsStandardScheme getScheme() { - return new stopDownloads_argsStandardScheme(); - } - } + static { + schemes.put(StandardScheme.class, new getAccounts_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAccounts_resultTupleSchemeFactory()); + } - private static class stopDownloads_argsStandardScheme extends StandardScheme<stopDownloads_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, stopDownloads_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: // FIDS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list282 = iprot.readListBegin(); - struct.fids = new ArrayList<Integer>(_list282.size); - for (int _i283 = 0; _i283 < _list282.size; ++_i283) - { - int _elem284; // required - _elem284 = iprot.readI32(); - struct.fids.add(_elem284); - } - iprot.readListEnd(); - } - struct.setFidsIsSet(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, stopDownloads_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.fids != null) { - oprot.writeFieldBegin(FIDS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); - for (int _iter285 : struct.fids) - { - oprot.writeI32(_iter285); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public List<AccountInfo> success; // required - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeTypedList(success); + } - private static class stopDownloads_argsTupleSchemeFactory implements SchemeFactory { - public stopDownloads_argsTupleScheme getScheme() { - return new stopDownloads_argsTupleScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class stopDownloads_argsTupleScheme extends TupleScheme<stopDownloads_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, stopDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFids()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetFids()) { - { - oprot.writeI32(struct.fids.size()); - for (int _iter286 : struct.fids) - { - oprot.writeI32(_iter286); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, stopDownloads_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list287 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.fids = new ArrayList<Integer>(_list287.size); - for (int _i288 = 0; _i288 < _list287.size; ++_i288) - { - int _elem289; // required - _elem289 = iprot.readI32(); - struct.fids.add(_elem289); - } - } - struct.setFidsIsSet(true); - } - } - } + public getAccounts_result(android.os.Parcel in) { + this.success = new ArrayList<AccountInfo>(); + in.readTypedList(this.success, AccountInfo.CREATOR); + } - } + public static final android.os.Parcelable.Creator<getAccounts_result> CREATOR = new android.os.Parcelable.Creator<getAccounts_result>() { + @Override + public getAccounts_result[] newArray(int size) { + return new getAccounts_result[size]; + } - public static class stopDownloads_result implements org.apache.thrift.TBase<stopDownloads_result, stopDownloads_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("stopDownloads_result"); + @Override + public getAccounts_result createFromParcel(android.os.Parcel in) { + return new getAccounts_result(in); + } + }; + /** 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new stopDownloads_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new stopDownloads_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(stopDownloads_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public stopDownloads_result() { - } + /** + * 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; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public stopDownloads_result(stopDownloads_result other) { - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public stopDownloads_result deepCopy() { - return new stopDownloads_result(this); - } + private final short _thriftId; + private final String _fieldName; - @Override - public void clear() { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public short getThriftFieldId() { + return _thriftId; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public String getFieldName() { + return _fieldName; + } + } - /** 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(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - switch (field) { - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, AccountInfo.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccounts_result.class, metaDataMap); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof stopDownloads_result) - return this.equals((stopDownloads_result)that); - return false; - } + public getAccounts_result() { + } - public boolean equals(stopDownloads_result that) { - if (that == null) - return false; + public getAccounts_result( + List<AccountInfo> success) { + this(); + this.success = success; + } - return true; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAccounts_result(getAccounts_result other) { + if (other.isSetSuccess()) { + List<AccountInfo> __this__success = new ArrayList<AccountInfo>(other.success.size()); + for (AccountInfo other_element : other.success) { + __this__success.add(new AccountInfo(other_element)); + } + this.success = __this__success; + } + } - @Override - public int hashCode() { - return 0; - } + public getAccounts_result deepCopy() { + return new getAccounts_result(this); + } - public int compareTo(stopDownloads_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public void clear() { + this.success = null; + } - int lastComparison = 0; - stopDownloads_result typedOther = (stopDownloads_result)other; + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - return 0; - } + public java.util.Iterator<AccountInfo> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void addToSuccess(AccountInfo elem) { + if (this.success == null) { + this.success = new ArrayList<AccountInfo>(); + } + this.success.add(elem); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public List<AccountInfo> getSuccess() { + return this.success; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public getAccounts_result setSuccess(List<AccountInfo> success) { + this.success = success; + return this; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("stopDownloads_result("); - boolean first = true; + public void unsetSuccess() { + this.success = null; + } - sb.append(")"); - return sb.toString(); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<AccountInfo>) value); + } + break; - 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.getMessage()); - } - } + } + } - private static class stopDownloads_resultStandardSchemeFactory implements SchemeFactory { - public stopDownloads_resultStandardScheme getScheme() { - return new stopDownloads_resultStandardScheme(); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - private static class stopDownloads_resultStandardScheme extends StandardScheme<stopDownloads_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, stopDownloads_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) { - 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, stopDownloads_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } + 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(); + } - private static class stopDownloads_resultTupleSchemeFactory implements SchemeFactory { - public stopDownloads_resultTupleScheme getScheme() { - return new stopDownloads_resultTupleScheme(); - } - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - private static class stopDownloads_resultTupleScheme extends TupleScheme<stopDownloads_result> { + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAccounts_result) + return this.equals((getAccounts_result) that); + return false; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, stopDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public boolean equals(getAccounts_result that) { + if (that == null) + return false; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, stopDownloads_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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; + } - public static class setPackageName_args implements org.apache.thrift.TBase<setPackageName_args, setPackageName_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageName_args"); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("name", org.apache.thrift.protocol.TType.STRING, (short)2); + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setPackageName_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setPackageName_argsTupleSchemeFactory()); - } + return list.hashCode(); + } - public int pid; // required - public 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 { - PID((short)1, "pid"), - NAME((short)2, "name"); - - 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: // PID - return PID; - case 2: // 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 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; - } - } + @Override + public int compareTo(getAccounts_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - 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))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageName_args.class, metaDataMap); - } + int lastComparison = 0; - public setPackageName_args() { - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public setPackageName_args( - int pid, - String name) - { - this(); - this.pid = pid; - setPidIsSet(true); - this.name = name; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setPackageName_args(setPackageName_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - if (other.isSetName()) { - this.name = other.name; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public setPackageName_args deepCopy() { - return new setPackageName_args(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 void clear() { - setPidIsSet(false); - this.pid = 0; - this.name = null; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAccounts_result("); + boolean first = true; - public int getPid() { - return this.pid; - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public setPackageName_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + private static class getAccounts_resultStandardSchemeFactory implements SchemeFactory { + public getAccounts_resultStandardScheme getScheme() { + return new getAccounts_resultStandardScheme(); + } + } - public String getName() { - return this.name; - } + private static class getAccounts_resultStandardScheme extends StandardScheme<getAccounts_result> { - public setPackageName_args setName(String name) { - this.name = name; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAccounts_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 ArrayList<AccountInfo>(_list348.size); + AccountInfo _elem349; + for (int _i350 = 0; _i350 < _list348.size; ++_i350) { + _elem349 = new AccountInfo(); + _elem349.read(iprot); + struct.success.add(_elem349); + } + iprot.readListEnd(); + } + 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(); - public void unsetName() { - this.name = null; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAccounts_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } + 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 (AccountInfo _iter351 : struct.success) { + _iter351.write(oprot); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); } - break; - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); + private static class getAccounts_resultTupleSchemeFactory implements SchemeFactory { + public getAccounts_resultTupleScheme getScheme() { + return new getAccounts_resultTupleScheme(); + } } - break; - } - } + private static class getAccounts_resultTupleScheme extends TupleScheme<getAccounts_result> { - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAccounts_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (AccountInfo _iter352 : struct.success) { + _iter352.write(oprot); + } + } + } + } - case NAME: - return getName(); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAccounts_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list353 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new ArrayList<AccountInfo>(_list353.size); + AccountInfo _elem354; + for (int _i355 = 0; _i355 < _list353.size; ++_i355) { + _elem354 = new AccountInfo(); + _elem354.read(iprot); + struct.success.add(_elem354); + } + } + struct.setSuccessIsSet(true); + } + } + } - } - 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 PID: - return isSetPid(); - case NAME: - return isSetName(); - } - throw new IllegalStateException(); - } + public static class getAccountTypes_args implements org.apache.thrift.TBase<getAccountTypes_args, getAccountTypes_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAccountTypes_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccountTypes_args"); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setPackageName_args) - return this.equals((setPackageName_args)that); - return false; - } - public boolean equals(setPackageName_args that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - 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; - } - - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new getAccountTypes_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAccountTypes_argsTupleSchemeFactory()); + } - public int compareTo(setPackageName_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - setPackageName_args typedOther = (setPackageName_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int describeContents() { + return 0; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public getAccountTypes_args(android.os.Parcel in) { + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setPackageName_args("); - boolean first = true; - - sb.append("pid:"); - sb.append(this.pid); - first = false; - if (!first) sb.append(", "); - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public static final android.os.Parcelable.Creator<getAccountTypes_args> CREATOR = new android.os.Parcelable.Creator<getAccountTypes_args>() { + @Override + public getAccountTypes_args[] newArray(int size) { + return new getAccountTypes_args[size]; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public getAccountTypes_args createFromParcel(android.os.Parcel in) { + return new getAccountTypes_args(in); + } + }; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** 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 void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class setPackageName_argsStandardSchemeFactory implements SchemeFactory { - public setPackageName_argsStandardScheme getScheme() { - return new setPackageName_argsStandardScheme(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class setPackageName_argsStandardScheme extends StandardScheme<setPackageName_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageName_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // 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, setPackageName_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - if (struct.name != null) { - oprot.writeFieldBegin(NAME_FIELD_DESC); - oprot.writeString(struct.name); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } - private static class setPackageName_argsTupleSchemeFactory implements SchemeFactory { - public setPackageName_argsTupleScheme getScheme() { - return new setPackageName_argsTupleScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class setPackageName_argsTupleScheme extends TupleScheme<setPackageName_args> { + private final short _thriftId; + private final String _fieldName; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setPackageName_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - if (struct.isSetName()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setPackageName_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } } - if (incoming.get(1)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); + + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccountTypes_args.class, metaDataMap); } - } - } - } + public getAccountTypes_args() { + } - public static class setPackageName_result implements org.apache.thrift.TBase<setPackageName_result, setPackageName_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageName_result"); + /** + * Performs a deep copy on <i>other</i>. + */ + public getAccountTypes_args(getAccountTypes_args other) { + } + public getAccountTypes_args deepCopy() { + return new getAccountTypes_args(this); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setPackageName_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setPackageName_resultTupleSchemeFactory()); - } + @Override + public void clear() { + } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageName_result.class, metaDataMap); - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public setPackageName_result() { - } + /** 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(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setPackageName_result(setPackageName_result other) { - } + switch (field) { + } + throw new IllegalStateException(); + } - public setPackageName_result deepCopy() { - return new setPackageName_result(this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAccountTypes_args) + return this.equals((getAccountTypes_args) that); + return false; + } - @Override - public void clear() { - } + public boolean equals(getAccountTypes_args that) { + if (that == null) + return false; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + return true; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - /** 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(); - } + return list.hashCode(); + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int compareTo(getAccountTypes_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setPackageName_result) - return this.equals((setPackageName_result)that); - return false; - } + int lastComparison = 0; - public boolean equals(setPackageName_result that) { - if (that == null) - return false; + return 0; + } - return true; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int compareTo(setPackageName_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - int lastComparison = 0; - setPackageName_result typedOther = (setPackageName_result)other; + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAccountTypes_args("); + boolean first = true; - return 0; - } + sb.append(")"); + return sb.toString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setPackageName_result("); - boolean first = true; + private static class getAccountTypes_argsStandardSchemeFactory implements SchemeFactory { + public getAccountTypes_argsStandardScheme getScheme() { + return new getAccountTypes_argsStandardScheme(); + } + } - sb.append(")"); - return sb.toString(); - } + private static class getAccountTypes_argsStandardScheme extends StandardScheme<getAccountTypes_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAccountTypes_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(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAccountTypes_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class setPackageName_resultStandardSchemeFactory implements SchemeFactory { - public setPackageName_resultStandardScheme getScheme() { - return new setPackageName_resultStandardScheme(); - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class setPackageName_resultStandardScheme extends StandardScheme<setPackageName_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageName_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) { - 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, setPackageName_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } - } + private static class getAccountTypes_argsTupleSchemeFactory implements SchemeFactory { + public getAccountTypes_argsTupleScheme getScheme() { + return new getAccountTypes_argsTupleScheme(); + } + } - private static class setPackageName_resultTupleSchemeFactory implements SchemeFactory { - public setPackageName_resultTupleScheme getScheme() { - return new setPackageName_resultTupleScheme(); - } - } + private static class getAccountTypes_argsTupleScheme extends TupleScheme<getAccountTypes_args> { - private static class setPackageName_resultTupleScheme extends TupleScheme<setPackageName_result> { + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setPackageName_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setPackageName_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } } - } + public static class getAccountTypes_result implements org.apache.thrift.TBase<getAccountTypes_result, getAccountTypes_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAccountTypes_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccountTypes_result"); - public static class movePackage_args implements org.apache.thrift.TBase<movePackage_args, movePackage_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("movePackage_args"); + 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 DESTINATION_FIELD_DESC = new org.apache.thrift.protocol.TField("destination", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)2); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new movePackage_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new movePackage_argsTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new getAccountTypes_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAccountTypes_resultTupleSchemeFactory()); + } - /** - * - * @see Destination - */ - public Destination destination; // required - public int pid; // 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 Destination - */ - DESTINATION((short)1, "destination"), - PID((short)2, "pid"); - - 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: // DESTINATION - return DESTINATION; - case 2: // PID - return PID; - 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; - } - } + public List<String> success; // required - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.DESTINATION, new org.apache.thrift.meta_data.FieldMetaData("destination", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, Destination.class))); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(movePackage_args.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeList(success); + } - public movePackage_args() { - } + @Override + public int describeContents() { + return 0; + } - public movePackage_args( - Destination destination, - int pid) - { - this(); - this.destination = destination; - this.pid = pid; - setPidIsSet(true); - } + public getAccountTypes_result(android.os.Parcel in) { + this.success = new ArrayList<String>(); + in.readList(this.success, getAccountTypes_result.class.getClassLoader()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public movePackage_args(movePackage_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetDestination()) { - this.destination = other.destination; - } - this.pid = other.pid; - } + public static final android.os.Parcelable.Creator<getAccountTypes_result> CREATOR = new android.os.Parcelable.Creator<getAccountTypes_result>() { + @Override + public getAccountTypes_result[] newArray(int size) { + return new getAccountTypes_result[size]; + } - public movePackage_args deepCopy() { - return new movePackage_args(this); - } + @Override + public getAccountTypes_result createFromParcel(android.os.Parcel in) { + return new getAccountTypes_result(in); + } + }; - @Override - public void clear() { - this.destination = null; - setPidIsSet(false); - this.pid = 0; - } + /** 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"); - /** - * - * @see Destination - */ - public Destination getDestination() { - return this.destination; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** - * - * @see Destination - */ - public movePackage_args setDestination(Destination destination) { - this.destination = destination; - return this; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void unsetDestination() { - this.destination = null; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - /** Returns true if field destination is set (has been assigned a value) and false otherwise */ - public boolean isSetDestination() { - return this.destination != 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; + } - public void setDestinationIsSet(boolean value) { - if (!value) { - this.destination = null; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public int getPid() { - return this.pid; - } + private final short _thriftId; + private final String _fieldName; - public movePackage_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + public String getFieldName() { + return _fieldName; + } + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case DESTINATION: - if (value == null) { - unsetDestination(); - } else { - setDestination((Destination)value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccountTypes_result.class, metaDataMap); } - break; - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + public getAccountTypes_result() { } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case DESTINATION: - return getDestination(); - case PID: - return Integer.valueOf(getPid()); - - } - 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 DESTINATION: - return isSetDestination(); - case PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + public getAccountTypes_result( + List<String> success) { + this(); + this.success = success; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof movePackage_args) - return this.equals((movePackage_args)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAccountTypes_result(getAccountTypes_result other) { + if (other.isSetSuccess()) { + List<String> __this__success = new ArrayList<String>(other.success); + this.success = __this__success; + } + } - public boolean equals(movePackage_args that) { - if (that == null) - return false; - - boolean this_present_destination = true && this.isSetDestination(); - boolean that_present_destination = true && that.isSetDestination(); - if (this_present_destination || that_present_destination) { - if (!(this_present_destination && that_present_destination)) - return false; - if (!this.destination.equals(that.destination)) - return false; - } - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } - - return true; - } + public getAccountTypes_result deepCopy() { + return new getAccountTypes_result(this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public void clear() { + this.success = null; + } - public int compareTo(movePackage_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - movePackage_args typedOther = (movePackage_args)other; - - lastComparison = Boolean.valueOf(isSetDestination()).compareTo(typedOther.isSetDestination()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDestination()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.destination, typedOther.destination); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public java.util.Iterator<String> getSuccessIterator() { + return (this.success == null) ? null : this.success.iterator(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void addToSuccess(String elem) { + if (this.success == null) { + this.success = new ArrayList<String>(); + } + this.success.add(elem); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public List<String> getSuccess() { + return this.success; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("movePackage_args("); - boolean first = true; - - sb.append("destination:"); - if (this.destination == null) { - sb.append("null"); - } else { - sb.append(this.destination); - } - first = false; - if (!first) sb.append(", "); - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + public getAccountTypes_result setSuccess(List<String> success) { + this.success = success; + return this; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void unsetSuccess() { + this.success = null; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - private static class movePackage_argsStandardSchemeFactory implements SchemeFactory { - public movePackage_argsStandardScheme getScheme() { - return new movePackage_argsStandardScheme(); - } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((List<String>) value); + } + break; - private static class movePackage_argsStandardScheme extends StandardScheme<movePackage_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, movePackage_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: // DESTINATION - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, movePackage_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.destination != null) { - oprot.writeFieldBegin(DESTINATION_FIELD_DESC); - oprot.writeI32(struct.destination.getValue()); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - private static class movePackage_argsTupleSchemeFactory implements SchemeFactory { - public movePackage_argsTupleScheme getScheme() { - return new movePackage_argsTupleScheme(); - } - } + } + throw new IllegalStateException(); + } - private static class movePackage_argsTupleScheme extends TupleScheme<movePackage_args> { + /** 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(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, movePackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetDestination()) { - optionals.set(0); - } - if (struct.isSetPid()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetDestination()) { - oprot.writeI32(struct.destination.getValue()); - } - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, movePackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.destination = Destination.findByValue(iprot.readI32()); - struct.setDestinationIsSet(true); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAccountTypes_result) + return this.equals((getAccountTypes_result) that); + return false; } - if (incoming.get(1)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + + public boolean equals(getAccountTypes_result that) { + if (that == null) + return false; + + boolean this_present_success = true && this.isSetSuccess(); + boolean that_present_success = true && that.isSetSuccess(); + if (this_present_success || that_present_success) { + if (!(this_present_success && that_present_success)) + return false; + if (!this.success.equals(that.success)) + return false; + } + + return true; } - } - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public static class movePackage_result implements org.apache.thrift.TBase<movePackage_result, movePackage_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("movePackage_result"); + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + return list.hashCode(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new movePackage_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new movePackage_resultTupleSchemeFactory()); - } + @Override + public int compareTo(getAccountTypes_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + int lastComparison = 0; - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(movePackage_result.class, metaDataMap); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public movePackage_result() { - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public movePackage_result(movePackage_result other) { - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public movePackage_result deepCopy() { - return new movePackage_result(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 void clear() { - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAccountTypes_result("); + boolean first = true; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** 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(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + 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); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof movePackage_result) - return this.equals((movePackage_result)that); - return false; - } + private static class getAccountTypes_resultStandardSchemeFactory implements SchemeFactory { + public getAccountTypes_resultStandardScheme getScheme() { + return new getAccountTypes_resultStandardScheme(); + } + } - public boolean equals(movePackage_result that) { - if (that == null) - return false; + private static class getAccountTypes_resultStandardScheme extends StandardScheme<getAccountTypes_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAccountTypes_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 _list356 = iprot.readListBegin(); + struct.success = new ArrayList<String>(_list356.size); + String _elem357; + for (int _i358 = 0; _i358 < _list356.size; ++_i358) { + _elem357 = iprot.readString(); + struct.success.add(_elem357); + } + iprot.readListEnd(); + } + 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(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(movePackage_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAccountTypes_result struct) throws org.apache.thrift.TException { + struct.validate(); - int lastComparison = 0; - movePackage_result typedOther = (movePackage_result)other; + 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 (String _iter359 : struct.success) { + oprot.writeString(_iter359); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - return 0; - } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static class getAccountTypes_resultTupleSchemeFactory implements SchemeFactory { + public getAccountTypes_resultTupleScheme getScheme() { + return new getAccountTypes_resultTupleScheme(); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class getAccountTypes_resultTupleScheme extends TupleScheme<getAccountTypes_result> { - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (String _iter360 : struct.success) { + oprot.writeString(_iter360); + } + } + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("movePackage_result("); - boolean first = true; + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TList _list361 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new ArrayList<String>(_list361.size); + String _elem362; + for (int _i363 = 0; _i363 < _list361.size; ++_i363) { + _elem362 = iprot.readString(); + struct.success.add(_elem362); + } + } + struct.setSuccessIsSet(true); + } + } + } - sb.append(")"); - return sb.toString(); } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public static class updateAccount_args implements org.apache.thrift.TBase<updateAccount_args, updateAccount_args._Fields>, java.io.Serializable, Cloneable, Comparable<updateAccount_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateAccount_args"); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField ACCOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("account", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short) 3); + private static final org.apache.thrift.protocol.TField OPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("options", org.apache.thrift.protocol.TType.MAP, (short) 4); - 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.getMessage()); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class movePackage_resultStandardSchemeFactory implements SchemeFactory { - public movePackage_resultStandardScheme getScheme() { - return new movePackage_resultStandardScheme(); - } - } + static { + schemes.put(StandardScheme.class, new updateAccount_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new updateAccount_argsTupleSchemeFactory()); + } - private static class movePackage_resultStandardScheme extends StandardScheme<movePackage_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, movePackage_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) { - 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, movePackage_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public String plugin; // required + public String account; // required + public String password; // required + public Map<String, String> options; // required - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(plugin); + out.writeString(account); + out.writeString(password); + out.writeMap(options); + } - private static class movePackage_resultTupleSchemeFactory implements SchemeFactory { - public movePackage_resultTupleScheme getScheme() { - return new movePackage_resultTupleScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class movePackage_resultTupleScheme extends TupleScheme<movePackage_result> { + public updateAccount_args(android.os.Parcel in) { + this.plugin = in.readString(); + this.account = in.readString(); + this.password = in.readString(); + this.options = new HashMap<String, String>(); + in.readMap(this.options, updateAccount_args.class.getClassLoader()); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, movePackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public static final android.os.Parcelable.Creator<updateAccount_args> CREATOR = new android.os.Parcelable.Creator<updateAccount_args>() { + @Override + public updateAccount_args[] newArray(int size) { + return new updateAccount_args[size]; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, movePackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public updateAccount_args createFromParcel(android.os.Parcel in) { + return new updateAccount_args(in); + } + }; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"), + ACCOUNT((short) 2, "account"), + PASSWORD((short) 3, "password"), + OPTIONS((short) 4, "options"); - public static class moveFiles_args implements org.apache.thrift.TBase<moveFiles_args, moveFiles_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("moveFiles_args"); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static final org.apache.thrift.protocol.TField FIDS_FIELD_DESC = new org.apache.thrift.protocol.TField("fids", org.apache.thrift.protocol.TType.LIST, (short)1); - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)2); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new moveFiles_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new moveFiles_argsTupleSchemeFactory()); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PLUGIN + return PLUGIN; + case 2: // ACCOUNT + return ACCOUNT; + case 3: // PASSWORD + return PASSWORD; + case 4: // OPTIONS + return OPTIONS; + default: + return null; + } + } - public List<Integer> fids; // required - public int pid; // 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 { - FIDS((short)1, "fids"), - PID((short)2, "pid"); - - 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: // FIDS - return FIDS; - case 2: // PID - return PID; - 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; - } - } + /** + * 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; + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.FIDS, new org.apache.thrift.meta_data.FieldMetaData("fids", 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.I32 , "FileID")))); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(moveFiles_args.class, metaDataMap); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public moveFiles_args() { - } + private final short _thriftId; + private final String _fieldName; - public moveFiles_args( - List<Integer> fids, - int pid) - { - this(); - this.fids = fids; - this.pid = pid; - setPidIsSet(true); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public moveFiles_args(moveFiles_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetFids()) { - List<Integer> __this__fids = new ArrayList<Integer>(); - for (Integer other_element : other.fids) { - __this__fids.add(other_element); - } - this.fids = __this__fids; - } - this.pid = other.pid; - } + public short getThriftFieldId() { + return _thriftId; + } - public moveFiles_args deepCopy() { - return new moveFiles_args(this); - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public void clear() { - this.fids = null; - setPidIsSet(false); - this.pid = 0; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.ACCOUNT, new org.apache.thrift.meta_data.FieldMetaData("account", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.OPTIONS, new org.apache.thrift.meta_data.FieldMetaData("options", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateAccount_args.class, metaDataMap); + } + + public updateAccount_args() { + } + + public updateAccount_args( + String plugin, + String account, + String password, + Map<String, String> options) { + this(); + this.plugin = plugin; + this.account = account; + this.password = password; + this.options = options; + } + + /** + * Performs a deep copy on <i>other</i>. + */ + public updateAccount_args(updateAccount_args other) { + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetAccount()) { + this.account = other.account; + } + if (other.isSetPassword()) { + this.password = other.password; + } + if (other.isSetOptions()) { + Map<String, String> __this__options = new HashMap<String, String>(other.options); + this.options = __this__options; + } + } - public int getFidsSize() { - return (this.fids == null) ? 0 : this.fids.size(); - } + public updateAccount_args deepCopy() { + return new updateAccount_args(this); + } - public java.util.Iterator<Integer> getFidsIterator() { - return (this.fids == null) ? null : this.fids.iterator(); - } + @Override + public void clear() { + this.plugin = null; + this.account = null; + this.password = null; + this.options = null; + } - public void addToFids(int elem) { - if (this.fids == null) { - this.fids = new ArrayList<Integer>(); - } - this.fids.add(elem); - } + public String getPlugin() { + return this.plugin; + } - public List<Integer> getFids() { - return this.fids; - } + public updateAccount_args setPlugin(String plugin) { + this.plugin = plugin; + return this; + } - public moveFiles_args setFids(List<Integer> fids) { - this.fids = fids; - return this; - } + public void unsetPlugin() { + this.plugin = null; + } - public void unsetFids() { - this.fids = null; - } + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } - /** Returns true if field fids is set (has been assigned a value) and false otherwise */ - public boolean isSetFids() { - return this.fids != null; - } + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } - public void setFidsIsSet(boolean value) { - if (!value) { - this.fids = null; - } - } + public String getAccount() { + return this.account; + } - public int getPid() { - return this.pid; - } + public updateAccount_args setAccount(String account) { + this.account = account; + return this; + } - public moveFiles_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + public void unsetAccount() { + this.account = null; + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + /** Returns true if field account is set (has been assigned a value) and false otherwise */ + public boolean isSetAccount() { + return this.account != null; + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + public void setAccountIsSet(boolean value) { + if (!value) { + this.account = null; + } + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + public String getPassword() { + return this.password; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FIDS: - if (value == null) { - unsetFids(); - } else { - setFids((List<Integer>)value); + public updateAccount_args setPassword(String password) { + this.password = password; + return this; } - break; - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + public void unsetPassword() { + this.password = null; } - break; - } - } + /** Returns true if field password is set (has been assigned a value) and false otherwise */ + public boolean isSetPassword() { + return this.password != null; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case FIDS: - return getFids(); + public void setPasswordIsSet(boolean value) { + if (!value) { + this.password = null; + } + } - case PID: - return Integer.valueOf(getPid()); + public int getOptionsSize() { + return (this.options == null) ? 0 : this.options.size(); + } - } - throw new IllegalStateException(); - } + public void putToOptions(String key, String val) { + if (this.options == null) { + this.options = new HashMap<String, String>(); + } + this.options.put(key, val); + } - /** 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 FIDS: - return isSetFids(); - case PID: - return isSetPid(); - } - throw new IllegalStateException(); - } + public Map<String, String> getOptions() { + return this.options; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof moveFiles_args) - return this.equals((moveFiles_args)that); - return false; - } + public updateAccount_args setOptions(Map<String, String> options) { + this.options = options; + return this; + } - public boolean equals(moveFiles_args that) { - if (that == null) - return false; - - boolean this_present_fids = true && this.isSetFids(); - boolean that_present_fids = true && that.isSetFids(); - if (this_present_fids || that_present_fids) { - if (!(this_present_fids && that_present_fids)) - return false; - if (!this.fids.equals(that.fids)) - return false; - } - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } - - return true; - } + public void unsetOptions() { + this.options = null; + } - @Override - public int hashCode() { - return 0; - } + /** Returns true if field options is set (has been assigned a value) and false otherwise */ + public boolean isSetOptions() { + return this.options != null; + } - public int compareTo(moveFiles_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - moveFiles_args typedOther = (moveFiles_args)other; - - lastComparison = Boolean.valueOf(isSetFids()).compareTo(typedOther.isSetFids()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFids()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fids, typedOther.fids); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void setOptionsIsSet(boolean value) { + if (!value) { + this.options = null; + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + case ACCOUNT: + if (value == null) { + unsetAccount(); + } else { + setAccount((String) value); + } + break; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + case PASSWORD: + if (value == null) { + unsetPassword(); + } else { + setPassword((String) value); + } + break; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("moveFiles_args("); - boolean first = true; - - sb.append("fids:"); - if (this.fids == null) { - sb.append("null"); - } else { - sb.append(this.fids); - } - first = false; - if (!first) sb.append(", "); - sb.append("pid:"); - sb.append(this.pid); - first = false; - sb.append(")"); - return sb.toString(); - } + case OPTIONS: + if (value == null) { + unsetOptions(); + } else { + setOptions((Map<String, String>) value); + } + break; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + case ACCOUNT: + return getAccount(); - private static class moveFiles_argsStandardSchemeFactory implements SchemeFactory { - public moveFiles_argsStandardScheme getScheme() { - return new moveFiles_argsStandardScheme(); - } - } + case PASSWORD: + return getPassword(); - private static class moveFiles_argsStandardScheme extends StandardScheme<moveFiles_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, moveFiles_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: // FIDS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list290 = iprot.readListBegin(); - struct.fids = new ArrayList<Integer>(_list290.size); - for (int _i291 = 0; _i291 < _list290.size; ++_i291) - { - int _elem292; // required - _elem292 = iprot.readI32(); - struct.fids.add(_elem292); - } - iprot.readListEnd(); - } - struct.setFidsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(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, moveFiles_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.fids != null) { - oprot.writeFieldBegin(FIDS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.fids.size())); - for (int _iter293 : struct.fids) - { - oprot.writeI32(_iter293); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + case OPTIONS: + return getOptions(); - } + } + throw new IllegalStateException(); + } - private static class moveFiles_argsTupleSchemeFactory implements SchemeFactory { - public moveFiles_argsTupleScheme getScheme() { - return new moveFiles_argsTupleScheme(); - } - } + /** 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(); + } - private static class moveFiles_argsTupleScheme extends TupleScheme<moveFiles_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, moveFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFids()) { - optionals.set(0); - } - if (struct.isSetPid()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetFids()) { - { - oprot.writeI32(struct.fids.size()); - for (int _iter294 : struct.fids) - { - oprot.writeI32(_iter294); - } - } - } - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, moveFiles_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list295 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.fids = new ArrayList<Integer>(_list295.size); - for (int _i296 = 0; _i296 < _list295.size; ++_i296) - { - int _elem297; // required - _elem297 = iprot.readI32(); - struct.fids.add(_elem297); - } - } - struct.setFidsIsSet(true); - } - if (incoming.get(1)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } - } - } + switch (field) { + case PLUGIN: + return isSetPlugin(); + case ACCOUNT: + return isSetAccount(); + case PASSWORD: + return isSetPassword(); + case OPTIONS: + return isSetOptions(); + } + throw new IllegalStateException(); + } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof updateAccount_args) + return this.equals((updateAccount_args) that); + return false; + } - public static class moveFiles_result implements org.apache.thrift.TBase<moveFiles_result, moveFiles_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("moveFiles_result"); + public boolean equals(updateAccount_args that) { + if (that == null) + return false; + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new moveFiles_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new moveFiles_resultTupleSchemeFactory()); - } + boolean this_present_account = true && this.isSetAccount(); + boolean that_present_account = true && that.isSetAccount(); + if (this_present_account || that_present_account) { + if (!(this_present_account && that_present_account)) + return false; + if (!this.account.equals(that.account)) + return false; + } + boolean this_present_password = true && this.isSetPassword(); + boolean that_present_password = true && that.isSetPassword(); + if (this_present_password || that_present_password) { + if (!(this_present_password && that_present_password)) + return false; + if (!this.password.equals(that.password)) + return false; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(moveFiles_result.class, metaDataMap); - } + boolean this_present_options = true && this.isSetOptions(); + boolean that_present_options = true && that.isSetOptions(); + if (this_present_options || that_present_options) { + if (!(this_present_options && that_present_options)) + return false; + if (!this.options.equals(that.options)) + return false; + } - public moveFiles_result() { - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public moveFiles_result(moveFiles_result other) { - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public moveFiles_result deepCopy() { - return new moveFiles_result(this); - } + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); - @Override - public void clear() { - } + boolean present_account = true && (isSetAccount()); + list.add(present_account); + if (present_account) + list.add(account); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + boolean present_password = true && (isSetPassword()); + list.add(present_password); + if (present_password) + list.add(password); - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + boolean present_options = true && (isSetOptions()); + list.add(present_options); + if (present_options) + list.add(options); - /** 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(); - } + return list.hashCode(); + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public int compareTo(updateAccount_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof moveFiles_result) - return this.equals((moveFiles_result)that); - return false; - } + int lastComparison = 0; - public boolean equals(moveFiles_result that) { - if (that == null) - return false; + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetAccount()).compareTo(other.isSetAccount()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAccount()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.account, other.account); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetPassword()).compareTo(other.isSetPassword()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPassword()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, other.password); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetOptions()).compareTo(other.isSetOptions()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetOptions()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.options, other.options); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - return true; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public int hashCode() { - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int compareTo(moveFiles_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - int lastComparison = 0; - moveFiles_result typedOther = (moveFiles_result)other; + @Override + public String toString() { + StringBuilder sb = new StringBuilder("updateAccount_args("); + boolean first = true; - return 0; - } + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("account:"); + if (this.account == null) { + sb.append("null"); + } else { + sb.append(this.account); + } + first = false; + if (!first) sb.append(", "); + sb.append("password:"); + if (this.password == null) { + sb.append("null"); + } else { + sb.append(this.password); + } + first = false; + if (!first) sb.append(", "); + sb.append("options:"); + if (this.options == null) { + sb.append("null"); + } else { + sb.append(this.options); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("moveFiles_result("); - boolean first = true; + private static class updateAccount_argsStandardSchemeFactory implements SchemeFactory { + public updateAccount_argsStandardScheme getScheme() { + return new updateAccount_argsStandardScheme(); + } + } - sb.append(")"); - return sb.toString(); - } + private static class updateAccount_argsStandardScheme extends StandardScheme<updateAccount_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot, updateAccount_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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // ACCOUNT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.account = iprot.readString(); + struct.setAccountIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // PASSWORD + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // OPTIONS + if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { + { + org.apache.thrift.protocol.TMap _map364 = iprot.readMapBegin(); + struct.options = new HashMap<String, String>(2 * _map364.size); + String _key365; + String _val366; + for (int _i367 = 0; _i367 < _map364.size; ++_i367) { + _key365 = iprot.readString(); + _val366 = iprot.readString(); + struct.options.put(_key365, _val366); + } + iprot.readMapEnd(); + } + struct.setOptionsIsSet(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(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, updateAccount_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class moveFiles_resultStandardSchemeFactory implements SchemeFactory { - public moveFiles_resultStandardScheme getScheme() { - return new moveFiles_resultStandardScheme(); - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.account != null) { + oprot.writeFieldBegin(ACCOUNT_FIELD_DESC); + oprot.writeString(struct.account); + oprot.writeFieldEnd(); + } + if (struct.password != null) { + oprot.writeFieldBegin(PASSWORD_FIELD_DESC); + oprot.writeString(struct.password); + oprot.writeFieldEnd(); + } + if (struct.options != null) { + oprot.writeFieldBegin(OPTIONS_FIELD_DESC); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.options.size())); + for (Map.Entry<String, String> _iter368 : struct.options.entrySet()) { + oprot.writeString(_iter368.getKey()); + oprot.writeString(_iter368.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class moveFiles_resultStandardScheme extends StandardScheme<moveFiles_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, moveFiles_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) { - 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, moveFiles_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } - } + private static class updateAccount_argsTupleSchemeFactory implements SchemeFactory { + public updateAccount_argsTupleScheme getScheme() { + return new updateAccount_argsTupleScheme(); + } + } - private static class moveFiles_resultTupleSchemeFactory implements SchemeFactory { - public moveFiles_resultTupleScheme getScheme() { - return new moveFiles_resultTupleScheme(); - } - } + private static class updateAccount_argsTupleScheme extends TupleScheme<updateAccount_args> { - private static class moveFiles_resultTupleScheme extends TupleScheme<moveFiles_result> { + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, updateAccount_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + if (struct.isSetAccount()) { + optionals.set(1); + } + if (struct.isSetPassword()) { + optionals.set(2); + } + if (struct.isSetOptions()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetAccount()) { + oprot.writeString(struct.account); + } + if (struct.isSetPassword()) { + oprot.writeString(struct.password); + } + if (struct.isSetOptions()) { + { + oprot.writeI32(struct.options.size()); + for (Map.Entry<String, String> _iter369 : struct.options.entrySet()) { + oprot.writeString(_iter369.getKey()); + oprot.writeString(_iter369.getValue()); + } + } + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, moveFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, updateAccount_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(1)) { + struct.account = iprot.readString(); + struct.setAccountIsSet(true); + } + if (incoming.get(2)) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } + if (incoming.get(3)) { + { + org.apache.thrift.protocol.TMap _map370 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.options = new HashMap<String, String>(2 * _map370.size); + String _key371; + String _val372; + for (int _i373 = 0; _i373 < _map370.size; ++_i373) { + _key371 = iprot.readString(); + _val372 = iprot.readString(); + struct.options.put(_key371, _val372); + } + } + struct.setOptionsIsSet(true); + } + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, moveFiles_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } } - } + public static class updateAccount_result implements org.apache.thrift.TBase<updateAccount_result, updateAccount_result._Fields>, java.io.Serializable, Cloneable, Comparable<updateAccount_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateAccount_result"); - public static class orderPackage_args implements org.apache.thrift.TBase<orderPackage_args, orderPackage_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderPackage_args"); - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField POSITION_FIELD_DESC = new org.apache.thrift.protocol.TField("position", org.apache.thrift.protocol.TType.I16, (short)2); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new orderPackage_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new orderPackage_argsTupleSchemeFactory()); - } + static { + schemes.put(StandardScheme.class, new updateAccount_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new updateAccount_resultTupleSchemeFactory()); + } - public int pid; // required - public short position; // 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 { - PID((short)1, "pid"), - POSITION((short)2, "position"); - - 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: // PID - return PID; - case 2: // POSITION - return POSITION; - default: - return null; - } - } - - /** - * Find the _Fields constant that matches fieldId, throwing an exception - * if it is not found. - */ - public static _Fields findByThriftIdOrThrow(int fieldId) { - _Fields fields = findByThriftId(fieldId); - if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private static final int __POSITION_ISSET_ID = 1; - private BitSet __isset_bit_vector = new BitSet(2); - 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.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.POSITION, new org.apache.thrift.meta_data.FieldMetaData("position", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderPackage_args.class, metaDataMap); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - public orderPackage_args() { - } + @Override + public int describeContents() { + return 0; + } - public orderPackage_args( - int pid, - short position) - { - this(); - this.pid = pid; - setPidIsSet(true); - this.position = position; - setPositionIsSet(true); - } + public updateAccount_result(android.os.Parcel in) { + } - /** - * Performs a deep copy on <i>other</i>. - */ - public orderPackage_args(orderPackage_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - this.position = other.position; - } + public static final android.os.Parcelable.Creator<updateAccount_result> CREATOR = new android.os.Parcelable.Creator<updateAccount_result>() { + @Override + public updateAccount_result[] newArray(int size) { + return new updateAccount_result[size]; + } - public orderPackage_args deepCopy() { - return new orderPackage_args(this); - } + @Override + public updateAccount_result createFromParcel(android.os.Parcel in) { + return new updateAccount_result(in); + } + }; - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - setPositionIsSet(false); - this.position = 0; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public int getPid() { - return this.pid; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public orderPackage_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + /** + * 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; + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public short getPosition() { - return this.position; - } + private final short _thriftId; + private final String _fieldName; - public orderPackage_args setPosition(short position) { - this.position = position; - setPositionIsSet(true); - return this; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void unsetPosition() { - __isset_bit_vector.clear(__POSITION_ISSET_ID); - } + public short getThriftFieldId() { + return _thriftId; + } - /** Returns true if field position is set (has been assigned a value) and false otherwise */ - public boolean isSetPosition() { - return __isset_bit_vector.get(__POSITION_ISSET_ID); - } + public String getFieldName() { + return _fieldName; + } + } - public void setPositionIsSet(boolean value) { - __isset_bit_vector.set(__POSITION_ISSET_ID, value); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateAccount_result.class, metaDataMap); } - break; - case POSITION: - if (value == null) { - unsetPosition(); - } else { - setPosition((Short)value); + public updateAccount_result() { } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); - - case POSITION: - return Short.valueOf(getPosition()); + /** + * Performs a deep copy on <i>other</i>. + */ + public updateAccount_result(updateAccount_result other) { + } - } - throw new IllegalStateException(); - } + public updateAccount_result deepCopy() { + return new updateAccount_result(this); + } - /** 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 PID: - return isSetPid(); - case POSITION: - return isSetPosition(); - } - throw new IllegalStateException(); - } + @Override + public void clear() { + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof orderPackage_args) - return this.equals((orderPackage_args)that); - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public boolean equals(orderPackage_args that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } - - boolean this_present_position = true; - boolean that_present_position = true; - if (this_present_position || that_present_position) { - if (!(this_present_position && that_present_position)) - return false; - if (this.position != that.position) - return false; - } - - return true; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + /** 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(); + } - public int compareTo(orderPackage_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - orderPackage_args typedOther = (orderPackage_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPosition()).compareTo(typedOther.isSetPosition()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPosition()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.position, typedOther.position); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + switch (field) { + } + throw new IllegalStateException(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof updateAccount_result) + return this.equals((updateAccount_result) that); + return false; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public boolean equals(updateAccount_result that) { + if (that == null) + return false; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + return true; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("orderPackage_args("); - boolean first = true; - - sb.append("pid:"); - sb.append(this.pid); - first = false; - if (!first) sb.append(", "); - sb.append("position:"); - sb.append(this.position); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(updateAccount_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + int lastComparison = 0; - private static class orderPackage_argsStandardSchemeFactory implements SchemeFactory { - public orderPackage_argsStandardScheme getScheme() { - return new orderPackage_argsStandardScheme(); - } - } + return 0; + } - private static class orderPackage_argsStandardScheme extends StandardScheme<orderPackage_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, orderPackage_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // POSITION - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.position = iprot.readI16(); - struct.setPositionIsSet(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, orderPackage_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(POSITION_FIELD_DESC); - oprot.writeI16(struct.position); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class orderPackage_argsTupleSchemeFactory implements SchemeFactory { - public orderPackage_argsTupleScheme getScheme() { - return new orderPackage_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class orderPackage_argsTupleScheme extends TupleScheme<orderPackage_args> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("updateAccount_result("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, orderPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - if (struct.isSetPosition()) { - optionals.set(1); + sb.append(")"); + return sb.toString(); } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - if (struct.isSetPosition()) { - oprot.writeI16(struct.position); + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, orderPackage_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - if (incoming.get(1)) { - struct.position = iprot.readI16(); - struct.setPositionIsSet(true); + + 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 updateAccount_resultStandardSchemeFactory implements SchemeFactory { + public updateAccount_resultStandardScheme getScheme() { + return new updateAccount_resultStandardScheme(); + } + } - public static class orderPackage_result implements org.apache.thrift.TBase<orderPackage_result, orderPackage_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderPackage_result"); + private static class updateAccount_resultStandardScheme extends StandardScheme<updateAccount_result> { + public void read(org.apache.thrift.protocol.TProtocol iprot, updateAccount_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new orderPackage_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new orderPackage_resultTupleSchemeFactory()); - } + // 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, updateAccount_result struct) throws org.apache.thrift.TException { + struct.validate(); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderPackage_result.class, metaDataMap); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public orderPackage_result() { - } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public orderPackage_result(orderPackage_result other) { - } + private static class updateAccount_resultTupleSchemeFactory implements SchemeFactory { + public updateAccount_resultTupleScheme getScheme() { + return new updateAccount_resultTupleScheme(); + } + } - public orderPackage_result deepCopy() { - return new orderPackage_result(this); - } + private static class updateAccount_resultTupleScheme extends TupleScheme<updateAccount_result> { - @Override - public void clear() { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, updateAccount_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, updateAccount_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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) { - } - throw new IllegalStateException(); - } + public static class removeAccount_args implements org.apache.thrift.TBase<removeAccount_args, removeAccount_args._Fields>, java.io.Serializable, Cloneable, Comparable<removeAccount_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("removeAccount_args"); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof orderPackage_result) - return this.equals((orderPackage_result)that); - return false; - } + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField ACCOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("account", org.apache.thrift.protocol.TType.STRING, (short) 2); - public boolean equals(orderPackage_result that) { - if (that == null) - return false; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - return true; - } + static { + schemes.put(StandardScheme.class, new removeAccount_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new removeAccount_argsTupleSchemeFactory()); + } - @Override - public int hashCode() { - return 0; - } + public String plugin; // required + public String account; // required - public int compareTo(orderPackage_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(plugin); + out.writeString(account); + } - int lastComparison = 0; - orderPackage_result typedOther = (orderPackage_result)other; + @Override + public int describeContents() { + return 0; + } - return 0; - } + public removeAccount_args(android.os.Parcel in) { + this.plugin = in.readString(); + this.account = in.readString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static final android.os.Parcelable.Creator<removeAccount_args> CREATOR = new android.os.Parcelable.Creator<removeAccount_args>() { + @Override + public removeAccount_args[] newArray(int size) { + return new removeAccount_args[size]; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public removeAccount_args createFromParcel(android.os.Parcel in) { + return new removeAccount_args(in); + } + }; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"), + ACCOUNT((short) 2, "account"); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("orderPackage_result("); - boolean first = true; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - sb.append(")"); - return sb.toString(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PLUGIN + return PLUGIN; + case 2: // ACCOUNT + return ACCOUNT; + default: + return null; + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * 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; + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class orderPackage_resultStandardSchemeFactory implements SchemeFactory { - public orderPackage_resultStandardScheme getScheme() { - return new orderPackage_resultStandardScheme(); - } - } + private final short _thriftId; + private final String _fieldName; - private static class orderPackage_resultStandardScheme extends StandardScheme<orderPackage_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, orderPackage_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) { - 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, orderPackage_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class orderPackage_resultTupleSchemeFactory implements SchemeFactory { - public orderPackage_resultTupleScheme getScheme() { - return new orderPackage_resultTupleScheme(); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class orderPackage_resultTupleScheme extends TupleScheme<orderPackage_result> { + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, orderPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.ACCOUNT, new org.apache.thrift.meta_data.FieldMetaData("account", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(removeAccount_args.class, metaDataMap); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, orderPackage_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public removeAccount_args() { + } - } + public removeAccount_args( + String plugin, + String account) { + this(); + this.plugin = plugin; + this.account = account; + } - public static class orderFile_args implements org.apache.thrift.TBase<orderFile_args, orderFile_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderFile_args"); + /** + * Performs a deep copy on <i>other</i>. + */ + public removeAccount_args(removeAccount_args other) { + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetAccount()) { + this.account = other.account; + } + } - private static final org.apache.thrift.protocol.TField FID_FIELD_DESC = new org.apache.thrift.protocol.TField("fid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField POSITION_FIELD_DESC = new org.apache.thrift.protocol.TField("position", org.apache.thrift.protocol.TType.I16, (short)2); + public removeAccount_args deepCopy() { + return new removeAccount_args(this); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new orderFile_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new orderFile_argsTupleSchemeFactory()); - } + @Override + public void clear() { + this.plugin = null; + this.account = null; + } - public int fid; // required - public short position; // 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 { - FID((short)1, "fid"), - POSITION((short)2, "position"); - - 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: // FID - return FID; - case 2: // POSITION - return POSITION; - 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; - } - } + public String getPlugin() { + return this.plugin; + } - // isset id assignments - private static final int __FID_ISSET_ID = 0; - private static final int __POSITION_ISSET_ID = 1; - private BitSet __isset_bit_vector = new BitSet(2); - 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.FID, new org.apache.thrift.meta_data.FieldMetaData("fid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "FileID"))); - tmpMap.put(_Fields.POSITION, new org.apache.thrift.meta_data.FieldMetaData("position", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderFile_args.class, metaDataMap); - } + public removeAccount_args setPlugin(String plugin) { + this.plugin = plugin; + return this; + } - public orderFile_args() { - } + public void unsetPlugin() { + this.plugin = null; + } - public orderFile_args( - int fid, - short position) - { - this(); - this.fid = fid; - setFidIsSet(true); - this.position = position; - setPositionIsSet(true); - } + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public orderFile_args(orderFile_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.fid = other.fid; - this.position = other.position; - } + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } - public orderFile_args deepCopy() { - return new orderFile_args(this); - } + public String getAccount() { + return this.account; + } - @Override - public void clear() { - setFidIsSet(false); - this.fid = 0; - setPositionIsSet(false); - this.position = 0; - } + public removeAccount_args setAccount(String account) { + this.account = account; + return this; + } - public int getFid() { - return this.fid; - } + public void unsetAccount() { + this.account = null; + } - public orderFile_args setFid(int fid) { - this.fid = fid; - setFidIsSet(true); - return this; - } + /** Returns true if field account is set (has been assigned a value) and false otherwise */ + public boolean isSetAccount() { + return this.account != null; + } - public void unsetFid() { - __isset_bit_vector.clear(__FID_ISSET_ID); - } + public void setAccountIsSet(boolean value) { + if (!value) { + this.account = null; + } + } - /** Returns true if field fid is set (has been assigned a value) and false otherwise */ - public boolean isSetFid() { - return __isset_bit_vector.get(__FID_ISSET_ID); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; - public void setFidIsSet(boolean value) { - __isset_bit_vector.set(__FID_ISSET_ID, value); - } + case ACCOUNT: + if (value == null) { + unsetAccount(); + } else { + setAccount((String) value); + } + break; - public short getPosition() { - return this.position; - } + } + } - public orderFile_args setPosition(short position) { - this.position = position; - setPositionIsSet(true); - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); - public void unsetPosition() { - __isset_bit_vector.clear(__POSITION_ISSET_ID); - } + case ACCOUNT: + return getAccount(); - /** Returns true if field position is set (has been assigned a value) and false otherwise */ - public boolean isSetPosition() { - return __isset_bit_vector.get(__POSITION_ISSET_ID); - } + } + throw new IllegalStateException(); + } - public void setPositionIsSet(boolean value) { - __isset_bit_vector.set(__POSITION_ISSET_ID, value); - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case FID: - if (value == null) { - unsetFid(); - } else { - setFid((Integer)value); + switch (field) { + case PLUGIN: + return isSetPlugin(); + case ACCOUNT: + return isSetAccount(); + } + throw new IllegalStateException(); } - break; - case POSITION: - if (value == null) { - unsetPosition(); - } else { - setPosition((Short)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof removeAccount_args) + return this.equals((removeAccount_args) that); + return false; } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case FID: - return Integer.valueOf(getFid()); - case POSITION: - return Short.valueOf(getPosition()); + public boolean equals(removeAccount_args that) { + if (that == null) + return false; - } - 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 FID: - return isSetFid(); - case POSITION: - return isSetPosition(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof orderFile_args) - return this.equals((orderFile_args)that); - return false; - } - - public boolean equals(orderFile_args that) { - if (that == null) - return false; - - boolean this_present_fid = true; - boolean that_present_fid = true; - if (this_present_fid || that_present_fid) { - if (!(this_present_fid && that_present_fid)) - return false; - if (this.fid != that.fid) - return false; - } - - boolean this_present_position = true; - boolean that_present_position = true; - if (this_present_position || that_present_position) { - if (!(this_present_position && that_present_position)) - return false; - if (this.position != that.position) - return false; - } - - return true; - } - - @Override - public int hashCode() { - return 0; - } + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } - public int compareTo(orderFile_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - orderFile_args typedOther = (orderFile_args)other; - - lastComparison = Boolean.valueOf(isSetFid()).compareTo(typedOther.isSetFid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fid, typedOther.fid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPosition()).compareTo(typedOther.isSetPosition()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPosition()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.position, typedOther.position); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + boolean this_present_account = true && this.isSetAccount(); + boolean that_present_account = true && that.isSetAccount(); + if (this_present_account || that_present_account) { + if (!(this_present_account && that_present_account)) + return false; + if (!this.account.equals(that.account)) + return false; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + return true; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("orderFile_args("); - boolean first = true; - - sb.append("fid:"); - sb.append(this.fid); - first = false; - if (!first) sb.append(", "); - sb.append("position:"); - sb.append(this.position); - first = false; - sb.append(")"); - return sb.toString(); - } + boolean present_account = true && (isSetAccount()); + list.add(present_account); + if (present_account) + list.add(account); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(removeAccount_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + int lastComparison = 0; - private static class orderFile_argsStandardSchemeFactory implements SchemeFactory { - public orderFile_argsStandardScheme getScheme() { - return new orderFile_argsStandardScheme(); - } - } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetAccount()).compareTo(other.isSetAccount()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetAccount()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.account, other.account); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - private static class orderFile_argsStandardScheme extends StandardScheme<orderFile_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, orderFile_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: // FID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // POSITION - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.position = iprot.readI16(); - struct.setPositionIsSet(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, orderFile_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(FID_FIELD_DESC); - oprot.writeI32(struct.fid); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(POSITION_FIELD_DESC); - oprot.writeI16(struct.position); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class orderFile_argsTupleSchemeFactory implements SchemeFactory { - public orderFile_argsTupleScheme getScheme() { - return new orderFile_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class orderFile_argsTupleScheme extends TupleScheme<orderFile_args> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("removeAccount_args("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, orderFile_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetFid()) { - optionals.set(0); - } - if (struct.isSetPosition()) { - optionals.set(1); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("account:"); + if (this.account == null) { + sb.append("null"); + } else { + sb.append(this.account); + } + first = false; + sb.append(")"); + return sb.toString(); } - oprot.writeBitSet(optionals, 2); - if (struct.isSetFid()) { - oprot.writeI32(struct.fid); + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - if (struct.isSetPosition()) { - oprot.writeI16(struct.position); + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, orderFile_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.fid = iprot.readI32(); - struct.setFidIsSet(true); + 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); + } } - if (incoming.get(1)) { - struct.position = iprot.readI16(); - struct.setPositionIsSet(true); + + private static class removeAccount_argsStandardSchemeFactory implements SchemeFactory { + public removeAccount_argsStandardScheme getScheme() { + return new removeAccount_argsStandardScheme(); + } } - } - } - } + private static class removeAccount_argsStandardScheme extends StandardScheme<removeAccount_args> { - public static class orderFile_result implements org.apache.thrift.TBase<orderFile_result, orderFile_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("orderFile_result"); + public void read(org.apache.thrift.protocol.TProtocol iprot, removeAccount_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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // ACCOUNT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.account = iprot.readString(); + struct.setAccountIsSet(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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new orderFile_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new orderFile_resultTupleSchemeFactory()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, removeAccount_args struct) throws org.apache.thrift.TException { + struct.validate(); + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.account != null) { + oprot.writeFieldBegin(ACCOUNT_FIELD_DESC); + oprot.writeString(struct.account); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(orderFile_result.class, metaDataMap); - } + } - public orderFile_result() { - } + private static class removeAccount_argsTupleSchemeFactory implements SchemeFactory { + public removeAccount_argsTupleScheme getScheme() { + return new removeAccount_argsTupleScheme(); + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public orderFile_result(orderFile_result other) { - } + private static class removeAccount_argsTupleScheme extends TupleScheme<removeAccount_args> { - public orderFile_result deepCopy() { - return new orderFile_result(this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, removeAccount_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + if (struct.isSetAccount()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetAccount()) { + oprot.writeString(struct.account); + } + } - @Override - public void clear() { - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, removeAccount_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(1)) { + struct.account = iprot.readString(); + struct.setAccountIsSet(true); + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public static class removeAccount_result implements org.apache.thrift.TBase<removeAccount_result, removeAccount_result._Fields>, java.io.Serializable, Cloneable, Comparable<removeAccount_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("removeAccount_result"); - /** 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) { - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof orderFile_result) - return this.equals((orderFile_result)that); - return false; - } + static { + schemes.put(StandardScheme.class, new removeAccount_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new removeAccount_resultTupleSchemeFactory()); + } - public boolean equals(orderFile_result that) { - if (that == null) - return false; - return true; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(orderFile_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public removeAccount_result(android.os.Parcel in) { + } - int lastComparison = 0; - orderFile_result typedOther = (orderFile_result)other; + public static final android.os.Parcelable.Creator<removeAccount_result> CREATOR = new android.os.Parcelable.Creator<removeAccount_result>() { + @Override + public removeAccount_result[] newArray(int size) { + return new removeAccount_result[size]; + } - return 0; - } + @Override + public removeAccount_result createFromParcel(android.os.Parcel in) { + return new removeAccount_result(in); + } + }; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("orderFile_result("); - boolean first = true; + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - sb.append(")"); - return sb.toString(); - } + /** + * 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; + } - public void validate() throws org.apache.thrift.TException { - // check for required 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 void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private final short _thriftId; + private final String _fieldName; - 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.getMessage()); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class orderFile_resultStandardSchemeFactory implements SchemeFactory { - public orderFile_resultStandardScheme getScheme() { - return new orderFile_resultStandardScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class orderFile_resultStandardScheme extends StandardScheme<orderFile_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, orderFile_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) { - 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, orderFile_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public String getFieldName() { + return _fieldName; + } + } - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class orderFile_resultTupleSchemeFactory implements SchemeFactory { - public orderFile_resultTupleScheme getScheme() { - return new orderFile_resultTupleScheme(); - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(removeAccount_result.class, metaDataMap); + } - private static class orderFile_resultTupleScheme extends TupleScheme<orderFile_result> { + public removeAccount_result() { + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, orderFile_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public removeAccount_result(removeAccount_result other) { + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, orderFile_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public removeAccount_result deepCopy() { + return new removeAccount_result(this); + } - } + @Override + public void clear() { + } - public static class setPackageData_args implements org.apache.thrift.TBase<setPackageData_args, setPackageData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageData_args"); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private static final org.apache.thrift.protocol.TField PID_FIELD_DESC = new org.apache.thrift.protocol.TField("pid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField DATA_FIELD_DESC = new org.apache.thrift.protocol.TField("data", org.apache.thrift.protocol.TType.MAP, (short)2); + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setPackageData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setPackageData_argsTupleSchemeFactory()); - } + /** 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(); + } - public int pid; // required - public Map<String,String> data; // 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 { - PID((short)1, "pid"), - DATA((short)2, "data"); - - 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: // PID - return PID; - case 2: // DATA - return DATA; - 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; - } - } + switch (field) { + } + throw new IllegalStateException(); + } - // isset id assignments - private static final int __PID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PID, new org.apache.thrift.meta_data.FieldMetaData("pid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID"))); - tmpMap.put(_Fields.DATA, new org.apache.thrift.meta_data.FieldMetaData("data", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageData_args.class, metaDataMap); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof removeAccount_result) + return this.equals((removeAccount_result) that); + return false; + } - public setPackageData_args() { - } + public boolean equals(removeAccount_result that) { + if (that == null) + return false; - public setPackageData_args( - int pid, - Map<String,String> data) - { - this(); - this.pid = pid; - setPidIsSet(true); - this.data = data; - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setPackageData_args(setPackageData_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pid = other.pid; - if (other.isSetData()) { - Map<String,String> __this__data = new HashMap<String,String>(); - for (Map.Entry<String, String> other_element : other.data.entrySet()) { + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - String other_element_key = other_element.getKey(); - String other_element_value = other_element.getValue(); + return list.hashCode(); + } - String __this__data_copy_key = other_element_key; + @Override + public int compareTo(removeAccount_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - String __this__data_copy_value = other_element_value; + int lastComparison = 0; - __this__data.put(__this__data_copy_key, __this__data_copy_value); + return 0; } - this.data = __this__data; - } - } - public setPackageData_args deepCopy() { - return new setPackageData_args(this); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public void clear() { - setPidIsSet(false); - this.pid = 0; - this.data = null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public int getPid() { - return this.pid; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public setPackageData_args setPid(int pid) { - this.pid = pid; - setPidIsSet(true); - return this; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("removeAccount_result("); + boolean first = true; - public void unsetPid() { - __isset_bit_vector.clear(__PID_ISSET_ID); - } + sb.append(")"); + return sb.toString(); + } - /** Returns true if field pid is set (has been assigned a value) and false otherwise */ - public boolean isSetPid() { - return __isset_bit_vector.get(__PID_ISSET_ID); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void setPidIsSet(boolean value) { - __isset_bit_vector.set(__PID_ISSET_ID, value); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public int getDataSize() { - return (this.data == null) ? 0 : this.data.size(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void putToData(String key, String val) { - if (this.data == null) { - this.data = new HashMap<String,String>(); - } - this.data.put(key, val); - } + private static class removeAccount_resultStandardSchemeFactory implements SchemeFactory { + public removeAccount_resultStandardScheme getScheme() { + return new removeAccount_resultStandardScheme(); + } + } - public Map<String,String> getData() { - return this.data; - } + private static class removeAccount_resultStandardScheme extends StandardScheme<removeAccount_result> { - public setPackageData_args setData(Map<String,String> data) { - this.data = data; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, removeAccount_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public void unsetData() { - this.data = null; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field data is set (has been assigned a value) and false otherwise */ - public boolean isSetData() { - return this.data != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, removeAccount_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void setDataIsSet(boolean value) { - if (!value) { - this.data = null; - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PID: - if (value == null) { - unsetPid(); - } else { - setPid((Integer)value); } - break; - case DATA: - if (value == null) { - unsetData(); - } else { - setData((Map<String,String>)value); + private static class removeAccount_resultTupleSchemeFactory implements SchemeFactory { + public removeAccount_resultTupleScheme getScheme() { + return new removeAccount_resultTupleScheme(); + } } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PID: - return Integer.valueOf(getPid()); - - case DATA: - return getData(); - } - throw new IllegalStateException(); - } + private static class removeAccount_resultTupleScheme extends TupleScheme<removeAccount_result> { - /** 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 PID: - return isSetPid(); - case DATA: - return isSetData(); - } - throw new IllegalStateException(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, removeAccount_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setPackageData_args) - return this.equals((setPackageData_args)that); - return false; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, removeAccount_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - public boolean equals(setPackageData_args that) { - if (that == null) - return false; - - boolean this_present_pid = true; - boolean that_present_pid = true; - if (this_present_pid || that_present_pid) { - if (!(this_present_pid && that_present_pid)) - return false; - if (this.pid != that.pid) - return false; - } - - boolean this_present_data = true && this.isSetData(); - boolean that_present_data = true && that.isSetData(); - if (this_present_data || that_present_data) { - if (!(this_present_data && that_present_data)) - return false; - if (!this.data.equals(that.data)) - return false; - } - - return true; } - @Override - public int hashCode() { - return 0; - } + public static class login_args implements org.apache.thrift.TBase<login_args, login_args._Fields>, java.io.Serializable, Cloneable, Comparable<login_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("login_args"); - public int compareTo(setPackageData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - setPackageData_args typedOther = (setPackageData_args)other; - - lastComparison = Boolean.valueOf(isSetPid()).compareTo(typedOther.isSetPid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pid, typedOther.pid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetData()).compareTo(typedOther.isSetData()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetData()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.data, typedOther.data); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + 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 PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short) 2); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + static { + schemes.put(StandardScheme.class, new login_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new login_argsTupleSchemeFactory()); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public String username; // required + public String password; // required - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setPackageData_args("); - boolean first = true; - - sb.append("pid:"); - sb.append(this.pid); - first = false; - if (!first) sb.append(", "); - sb.append("data:"); - if (this.data == null) { - sb.append("null"); - } else { - sb.append(this.data); - } - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(username); + out.writeString(password); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public int describeContents() { + return 0; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public login_args(android.os.Parcel in) { + this.username = in.readString(); + this.password = in.readString(); + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public static final android.os.Parcelable.Creator<login_args> CREATOR = new android.os.Parcelable.Creator<login_args>() { + @Override + public login_args[] newArray(int size) { + return new login_args[size]; + } - private static class setPackageData_argsStandardSchemeFactory implements SchemeFactory { - public setPackageData_argsStandardScheme getScheme() { - return new setPackageData_argsStandardScheme(); - } - } + @Override + public login_args createFromParcel(android.os.Parcel in) { + return new login_args(in); + } + }; - private static class setPackageData_argsStandardScheme extends StandardScheme<setPackageData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageData_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: // PID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // DATA - if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { - { - org.apache.thrift.protocol.TMap _map298 = iprot.readMapBegin(); - struct.data = new HashMap<String,String>(2*_map298.size); - for (int _i299 = 0; _i299 < _map298.size; ++_i299) - { - String _key300; // required - String _val301; // required - _key300 = iprot.readString(); - _val301 = iprot.readString(); - struct.data.put(_key300, _val301); - } - iprot.readMapEnd(); - } - struct.setDataIsSet(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, setPackageData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PID_FIELD_DESC); - oprot.writeI32(struct.pid); - oprot.writeFieldEnd(); - if (struct.data != null) { - oprot.writeFieldBegin(DATA_FIELD_DESC); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.data.size())); - for (Map.Entry<String, String> _iter302 : struct.data.entrySet()) - { - oprot.writeString(_iter302.getKey()); - oprot.writeString(_iter302.getValue()); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** 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"), + PASSWORD((short) 2, "password"); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class setPackageData_argsTupleSchemeFactory implements SchemeFactory { - public setPackageData_argsTupleScheme getScheme() { - return new setPackageData_argsTupleScheme(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class setPackageData_argsTupleScheme extends TupleScheme<setPackageData_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setPackageData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPid()) { - optionals.set(0); - } - if (struct.isSetData()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPid()) { - oprot.writeI32(struct.pid); - } - if (struct.isSetData()) { - { - oprot.writeI32(struct.data.size()); - for (Map.Entry<String, String> _iter303 : struct.data.entrySet()) - { - oprot.writeString(_iter303.getKey()); - oprot.writeString(_iter303.getValue()); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setPackageData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.pid = iprot.readI32(); - struct.setPidIsSet(true); - } - if (incoming.get(1)) { - { - org.apache.thrift.protocol.TMap _map304 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.data = new HashMap<String,String>(2*_map304.size); - for (int _i305 = 0; _i305 < _map304.size; ++_i305) - { - String _key306; // required - String _val307; // required - _key306 = iprot.readString(); - _val307 = iprot.readString(); - struct.data.put(_key306, _val307); - } - } - struct.setDataIsSet(true); - } - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // USERNAME + return USERNAME; + case 2: // PASSWORD + return PASSWORD; + 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; + } - public static class setPackageData_result implements org.apache.thrift.TBase<setPackageData_result, setPackageData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setPackageData_result"); + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static final org.apache.thrift.protocol.TField E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short)1); + private final short _thriftId; + private final String _fieldName; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setPackageData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setPackageData_resultTupleSchemeFactory()); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public PackageDoesNotExists e; // 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 { - E((short)1, "e"); - - 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: // E - return E; - 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; - } - } + public short getThriftFieldId() { + return _thriftId; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setPackageData_result.class, metaDataMap); - } + public String getFieldName() { + return _fieldName; + } + } - public setPackageData_result() { - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public setPackageData_result( - PackageDoesNotExists e) - { - this(); - this.e = e; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(login_args.class, metaDataMap); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setPackageData_result(setPackageData_result other) { - if (other.isSetE()) { - this.e = new PackageDoesNotExists(other.e); - } - } + public login_args() { + } - public setPackageData_result deepCopy() { - return new setPackageData_result(this); - } + public login_args( + String username, + String password) { + this(); + this.username = username; + this.password = password; + } - @Override - public void clear() { - this.e = null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public login_args(login_args other) { + if (other.isSetUsername()) { + this.username = other.username; + } + if (other.isSetPassword()) { + this.password = other.password; + } + } - public PackageDoesNotExists getE() { - return this.e; - } + public login_args deepCopy() { + return new login_args(this); + } - public setPackageData_result setE(PackageDoesNotExists e) { - this.e = e; - return this; - } + @Override + public void clear() { + this.username = null; + this.password = null; + } - public void unsetE() { - this.e = null; - } + public String getUsername() { + return this.username; + } - /** Returns true if field e is set (has been assigned a value) and false otherwise */ - public boolean isSetE() { - return this.e != null; - } + public login_args setUsername(String username) { + this.username = username; + return this; + } - public void setEIsSet(boolean value) { - if (!value) { - this.e = null; - } - } + public void unsetUsername() { + this.username = null; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case E: - if (value == null) { - unsetE(); - } else { - setE((PackageDoesNotExists)value); + /** Returns true if field username is set (has been assigned a value) and false otherwise */ + public boolean isSetUsername() { + return this.username != null; } - break; - } - } + public void setUsernameIsSet(boolean value) { + if (!value) { + this.username = null; + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - case E: - return getE(); + public String getPassword() { + return this.password; + } - } - throw new IllegalStateException(); - } + public login_args setPassword(String password) { + this.password = password; + return this; + } - /** 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 E: - return isSetE(); - } - throw new IllegalStateException(); - } + public void unsetPassword() { + this.password = null; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setPackageData_result) - return this.equals((setPackageData_result)that); - return false; - } + /** Returns true if field password is set (has been assigned a value) and false otherwise */ + public boolean isSetPassword() { + return this.password != null; + } - public boolean equals(setPackageData_result that) { - if (that == null) - return false; + public void setPasswordIsSet(boolean value) { + if (!value) { + this.password = null; + } + } - boolean this_present_e = true && this.isSetE(); - boolean that_present_e = true && that.isSetE(); - if (this_present_e || that_present_e) { - if (!(this_present_e && that_present_e)) - return false; - if (!this.e.equals(that.e)) - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case USERNAME: + if (value == null) { + unsetUsername(); + } else { + setUsername((String) value); + } + break; - return true; - } + case PASSWORD: + if (value == null) { + unsetPassword(); + } else { + setPassword((String) value); + } + break; - @Override - public int hashCode() { - return 0; - } + } + } - public int compareTo(setPackageData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - setPackageData_result typedOther = (setPackageData_result)other; - - lastComparison = Boolean.valueOf(isSetE()).compareTo(typedOther.isSetE()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetE()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, typedOther.e); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case USERNAME: + return getUsername(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + case PASSWORD: + return getPassword(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + } + throw new IllegalStateException(); + } - 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("setPackageData_result("); - boolean first = true; - - sb.append("e:"); - if (this.e == null) { - sb.append("null"); - } else { - sb.append(this.e); - } - first = false; - sb.append(")"); - return sb.toString(); - } + /** 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(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + switch (field) { + case USERNAME: + return isSetUsername(); + case PASSWORD: + return isSetPassword(); + } + throw new IllegalStateException(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof login_args) + return this.equals((login_args) that); + return false; + } - 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.getMessage()); - } - } + public boolean equals(login_args that) { + if (that == null) + return false; - private static class setPackageData_resultStandardSchemeFactory implements SchemeFactory { - public setPackageData_resultStandardScheme getScheme() { - return new setPackageData_resultStandardScheme(); - } - } + 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; + } - private static class setPackageData_resultStandardScheme extends StandardScheme<setPackageData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setPackageData_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: // E - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(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, setPackageData_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.e != null) { - oprot.writeFieldBegin(E_FIELD_DESC); - struct.e.write(oprot); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + boolean this_present_password = true && this.isSetPassword(); + boolean that_present_password = true && that.isSetPassword(); + if (this_present_password || that_present_password) { + if (!(this_present_password && that_present_password)) + return false; + if (!this.password.equals(that.password)) + return false; + } - } + return true; + } - private static class setPackageData_resultTupleSchemeFactory implements SchemeFactory { - public setPackageData_resultTupleScheme getScheme() { - return new setPackageData_resultTupleScheme(); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class setPackageData_resultTupleScheme extends TupleScheme<setPackageData_result> { + boolean present_username = true && (isSetUsername()); + list.add(present_username); + if (present_username) + list.add(username); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setPackageData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetE()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetE()) { - struct.e.write(oprot); - } - } + boolean present_password = true && (isSetPassword()); + list.add(present_password); + if (present_password) + list.add(password); - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setPackageData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.e = new PackageDoesNotExists(); - struct.e.read(iprot); - struct.setEIsSet(true); + return list.hashCode(); } - } - } - - } - public static class deleteFinished_args implements org.apache.thrift.TBase<deleteFinished_args, deleteFinished_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFinished_args"); + @Override + public int compareTo(login_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + int lastComparison = 0; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deleteFinished_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deleteFinished_argsTupleSchemeFactory()); - } + lastComparison = Boolean.valueOf(isSetUsername()).compareTo(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 = Boolean.valueOf(isSetPassword()).compareTo(other.isSetPassword()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPassword()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, other.password); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFinished_args.class, metaDataMap); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public deleteFinished_args() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public deleteFinished_args(deleteFinished_args other) { - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("login_args("); + boolean first = true; - public deleteFinished_args deepCopy() { - return new deleteFinished_args(this); - } + sb.append("username:"); + if (this.username == null) { + sb.append("null"); + } else { + sb.append(this.username); + } + first = false; + if (!first) sb.append(", "); + sb.append("password:"); + if (this.password == null) { + sb.append("null"); + } else { + sb.append(this.password); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public void clear() { - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + 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); + } + } - /** 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(); - } + private static class login_argsStandardSchemeFactory implements SchemeFactory { + public login_argsStandardScheme getScheme() { + return new login_argsStandardScheme(); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + private static class login_argsStandardScheme extends StandardScheme<login_args> { - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deleteFinished_args) - return this.equals((deleteFinished_args)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, login_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: // 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: // PASSWORD + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(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(); - public boolean equals(deleteFinished_args that) { - if (that == null) - return false; + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - return true; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, login_args struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public int hashCode() { - return 0; - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.username != null) { + oprot.writeFieldBegin(USERNAME_FIELD_DESC); + oprot.writeString(struct.username); + oprot.writeFieldEnd(); + } + if (struct.password != null) { + oprot.writeFieldBegin(PASSWORD_FIELD_DESC); + oprot.writeString(struct.password); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public int compareTo(deleteFinished_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + } - int lastComparison = 0; - deleteFinished_args typedOther = (deleteFinished_args)other; + private static class login_argsTupleSchemeFactory implements SchemeFactory { + public login_argsTupleScheme getScheme() { + return new login_argsTupleScheme(); + } + } - return 0; - } + private static class login_argsTupleScheme extends TupleScheme<login_args> { - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, login_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUsername()) { + optionals.set(0); + } + if (struct.isSetPassword()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetUsername()) { + oprot.writeString(struct.username); + } + if (struct.isSetPassword()) { + oprot.writeString(struct.password); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, login_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.username = iprot.readString(); + struct.setUsernameIsSet(true); + } + if (incoming.get(1)) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } + } + } - 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("deleteFinished_args("); - boolean first = true; + public static class login_result implements org.apache.thrift.TBase<login_result, login_result._Fields>, java.io.Serializable, Cloneable, Comparable<login_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("login_result"); - sb.append(")"); - return sb.toString(); - } + 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); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + schemes.put(StandardScheme.class, new login_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new login_resultTupleSchemeFactory()); + } - 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.getMessage()); - } - } + public boolean success; // required - private static class deleteFinished_argsStandardSchemeFactory implements SchemeFactory { - public deleteFinished_argsStandardScheme getScheme() { - return new deleteFinished_argsStandardScheme(); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - private static class deleteFinished_argsStandardScheme extends StandardScheme<deleteFinished_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFinished_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, deleteFinished_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + out.writeInt(success ? 1 : 0); + } - } + @Override + public int describeContents() { + return 0; + } - private static class deleteFinished_argsTupleSchemeFactory implements SchemeFactory { - public deleteFinished_argsTupleScheme getScheme() { - return new deleteFinished_argsTupleScheme(); - } - } + public login_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - private static class deleteFinished_argsTupleScheme extends TupleScheme<deleteFinished_args> { + this.success = (in.readInt() == 1); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deleteFinished_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public static final android.os.Parcelable.Creator<login_result> CREATOR = new android.os.Parcelable.Creator<login_result>() { + @Override + public login_result[] newArray(int size) { + return new login_result[size]; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deleteFinished_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public login_result createFromParcel(android.os.Parcel in) { + return new login_result(in); + } + }; - } + /** 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"); - public static class deleteFinished_result implements org.apache.thrift.TBase<deleteFinished_result, deleteFinished_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("deleteFinished_result"); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - 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); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new deleteFinished_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new deleteFinished_resultTupleSchemeFactory()); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public List<Integer> 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 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 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 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; - } - } + /** + * 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; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "PackageID")))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(deleteFinished_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public deleteFinished_result() { - } + private final short _thriftId; + private final String _fieldName; - public deleteFinished_result( - List<Integer> success) - { - this(); - this.success = success; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public deleteFinished_result(deleteFinished_result other) { - if (other.isSetSuccess()) { - List<Integer> __this__success = new ArrayList<Integer>(); - for (Integer other_element : other.success) { - __this__success.add(other_element); - } - this.success = __this__success; - } - } + public short getThriftFieldId() { + return _thriftId; + } - public deleteFinished_result deepCopy() { - return new deleteFinished_result(this); - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public void clear() { - this.success = null; - } + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(login_result.class, metaDataMap); + } - public java.util.Iterator<Integer> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + public login_result() { + } - public void addToSuccess(int elem) { - if (this.success == null) { - this.success = new ArrayList<Integer>(); - } - this.success.add(elem); - } + public login_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } - public List<Integer> getSuccess() { - return this.success; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public login_result(login_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } - public deleteFinished_result setSuccess(List<Integer> success) { - this.success = success; - return this; - } + public login_result deepCopy() { + return new login_result(this); + } - public void unsetSuccess() { - this.success = null; - } + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public boolean isSuccess() { + return this.success; + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public login_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<Integer>)value); + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); } - break; - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } - } - throw new IllegalStateException(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof deleteFinished_result) - return this.equals((deleteFinished_result)that); - return false; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); - public boolean equals(deleteFinished_result that) { - if (that == null) - return false; + } + throw new IllegalStateException(); + } - 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; - } + /** 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(); + } - return true; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - @Override - public int hashCode() { - return 0; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof login_result) + return this.equals((login_result) that); + return false; + } - public int compareTo(deleteFinished_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - deleteFinished_result typedOther = (deleteFinished_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public boolean equals(login_result that) { + if (that == null) + return false; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + return true; + } - 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("deleteFinished_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(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return list.hashCode(); + } - 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.getMessage()); - } - } + @Override + public int compareTo(login_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class deleteFinished_resultStandardSchemeFactory implements SchemeFactory { - public deleteFinished_resultStandardScheme getScheme() { - return new deleteFinished_resultStandardScheme(); - } - } + int lastComparison = 0; - private static class deleteFinished_resultStandardScheme extends StandardScheme<deleteFinished_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, deleteFinished_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 _list308 = iprot.readListBegin(); - struct.success = new ArrayList<Integer>(_list308.size); - for (int _i309 = 0; _i309 < _list308.size; ++_i309) - { - int _elem310; // required - _elem310 = iprot.readI32(); - struct.success.add(_elem310); - } - iprot.readListEnd(); - } - 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, deleteFinished_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.I32, struct.success.size())); - for (int _iter311 : struct.success) - { - oprot.writeI32(_iter311); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class deleteFinished_resultTupleSchemeFactory implements SchemeFactory { - public deleteFinished_resultTupleScheme getScheme() { - return new deleteFinished_resultTupleScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class deleteFinished_resultTupleScheme extends TupleScheme<deleteFinished_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, deleteFinished_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (int _iter312 : struct.success) - { - oprot.writeI32(_iter312); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, deleteFinished_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list313 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32()); - struct.success = new ArrayList<Integer>(_list313.size); - for (int _i314 = 0; _i314 < _list313.size; ++_i314) - { - int _elem315; // required - _elem315 = iprot.readI32(); - struct.success.add(_elem315); - } - } - struct.setSuccessIsSet(true); - } - } - } + 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("login_result("); + boolean first = true; - public static class restartFailed_args implements org.apache.thrift.TBase<restartFailed_args, restartFailed_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFailed_args"); + sb.append("success:"); + 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 static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartFailed_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartFailed_argsTupleSchemeFactory()); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFailed_args.class, metaDataMap); - } + private static class login_resultStandardSchemeFactory implements SchemeFactory { + public login_resultStandardScheme getScheme() { + return new login_resultStandardScheme(); + } + } - public restartFailed_args() { - } + private static class login_resultStandardScheme extends StandardScheme<login_result> { - /** - * Performs a deep copy on <i>other</i>. - */ - public restartFailed_args(restartFailed_args other) { - } + public void read(org.apache.thrift.protocol.TProtocol iprot, login_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; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - public restartFailed_args deepCopy() { - return new restartFailed_args(this); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void clear() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, login_result struct) throws org.apache.thrift.TException { + struct.validate(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.isSetSuccess()) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeBool(struct.success); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); - } + private static class login_resultTupleSchemeFactory implements SchemeFactory { + public login_resultTupleScheme getScheme() { + return new login_resultTupleScheme(); + } + } - switch (field) { - } - throw new IllegalStateException(); - } + private static class login_resultTupleScheme extends TupleScheme<login_result> { - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartFailed_args) - return this.equals((restartFailed_args)that); - return false; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, login_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } - public boolean equals(restartFailed_args that) { - if (that == null) - return false; + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, login_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } - return true; } - @Override - public int hashCode() { - return 0; - } + public static class getUserData_args implements org.apache.thrift.TBase<getUserData_args, getUserData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getUserData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserData_args"); - public int compareTo(restartFailed_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + 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 PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short) 2); - int lastComparison = 0; - restartFailed_args typedOther = (restartFailed_args)other; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - return 0; - } + static { + schemes.put(StandardScheme.class, new getUserData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getUserData_argsTupleSchemeFactory()); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public String username; // required + public String password; // required - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(username); + out.writeString(password); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + @Override + public int describeContents() { + return 0; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartFailed_args("); - boolean first = true; + public getUserData_args(android.os.Parcel in) { + this.username = in.readString(); + this.password = in.readString(); + } - sb.append(")"); - return sb.toString(); - } + public static final android.os.Parcelable.Creator<getUserData_args> CREATOR = new android.os.Parcelable.Creator<getUserData_args>() { + @Override + public getUserData_args[] newArray(int size) { + return new getUserData_args[size]; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public getUserData_args createFromParcel(android.os.Parcel in) { + return new getUserData_args(in); + } + }; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** 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"), + PASSWORD((short) 2, "password"); - 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.getMessage()); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class restartFailed_argsStandardSchemeFactory implements SchemeFactory { - public restartFailed_argsStandardScheme getScheme() { - return new restartFailed_argsStandardScheme(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class restartFailed_argsStandardScheme extends StandardScheme<restartFailed_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartFailed_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, restartFailed_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // USERNAME + return USERNAME; + case 2: // PASSWORD + return PASSWORD; + 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; + } - private static class restartFailed_argsTupleSchemeFactory implements SchemeFactory { - public restartFailed_argsTupleScheme getScheme() { - return new restartFailed_argsTupleScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class restartFailed_argsTupleScheme extends TupleScheme<restartFailed_args> { + private final short _thriftId; + private final String _fieldName; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartFailed_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartFailed_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public short getThriftFieldId() { + return _thriftId; + } - } + public String getFieldName() { + return _fieldName; + } + } - public static class restartFailed_result implements org.apache.thrift.TBase<restartFailed_result, restartFailed_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("restartFailed_result"); + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.USERNAME, new org.apache.thrift.meta_data.FieldMetaData("username", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserData_args.class, metaDataMap); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new restartFailed_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new restartFailed_resultTupleSchemeFactory()); - } + public getUserData_args() { + } + public getUserData_args( + String username, + String password) { + this(); + this.username = username; + this.password = password; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(restartFailed_result.class, metaDataMap); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getUserData_args(getUserData_args other) { + if (other.isSetUsername()) { + this.username = other.username; + } + if (other.isSetPassword()) { + this.password = other.password; + } + } - public restartFailed_result() { - } + public getUserData_args deepCopy() { + return new getUserData_args(this); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public restartFailed_result(restartFailed_result other) { - } + @Override + public void clear() { + this.username = null; + this.password = null; + } - public restartFailed_result deepCopy() { - return new restartFailed_result(this); - } + public String getUsername() { + return this.username; + } - @Override - public void clear() { - } + public getUserData_args setUsername(String username) { + this.username = username; + return this; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public void unsetUsername() { + this.username = null; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + /** Returns true if field username is set (has been assigned a value) and false otherwise */ + public boolean isSetUsername() { + return this.username != null; + } - /** 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(); - } + public void setUsernameIsSet(boolean value) { + if (!value) { + this.username = null; + } + } - switch (field) { - } - throw new IllegalStateException(); - } + public String getPassword() { + return this.password; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof restartFailed_result) - return this.equals((restartFailed_result)that); - return false; - } + public getUserData_args setPassword(String password) { + this.password = password; + return this; + } - public boolean equals(restartFailed_result that) { - if (that == null) - return false; + public void unsetPassword() { + this.password = null; + } - return true; - } + /** Returns true if field password is set (has been assigned a value) and false otherwise */ + public boolean isSetPassword() { + return this.password != null; + } - @Override - public int hashCode() { - return 0; - } + public void setPasswordIsSet(boolean value) { + if (!value) { + this.password = null; + } + } - public int compareTo(restartFailed_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case USERNAME: + if (value == null) { + unsetUsername(); + } else { + setUsername((String) value); + } + break; - int lastComparison = 0; - restartFailed_result typedOther = (restartFailed_result)other; + case PASSWORD: + if (value == null) { + unsetPassword(); + } else { + setPassword((String) value); + } + break; - return 0; - } + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case USERNAME: + return getUsername(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + case PASSWORD: + return getPassword(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + } + throw new IllegalStateException(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("restartFailed_result("); - boolean first = true; + /** 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(); + } - sb.append(")"); - return sb.toString(); - } + switch (field) { + case USERNAME: + return isSetUsername(); + case PASSWORD: + return isSetPassword(); + } + throw new IllegalStateException(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getUserData_args) + return this.equals((getUserData_args) that); + return false; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public boolean equals(getUserData_args that) { + if (that == null) + return false; - 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.getMessage()); - } - } + 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; + } - private static class restartFailed_resultStandardSchemeFactory implements SchemeFactory { - public restartFailed_resultStandardScheme getScheme() { - return new restartFailed_resultStandardScheme(); - } - } + boolean this_present_password = true && this.isSetPassword(); + boolean that_present_password = true && that.isSetPassword(); + if (this_present_password || that_present_password) { + if (!(this_present_password && that_present_password)) + return false; + if (!this.password.equals(that.password)) + return false; + } - private static class restartFailed_resultStandardScheme extends StandardScheme<restartFailed_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, restartFailed_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) { - 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, restartFailed_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return true; + } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class restartFailed_resultTupleSchemeFactory implements SchemeFactory { - public restartFailed_resultTupleScheme getScheme() { - return new restartFailed_resultTupleScheme(); - } - } + boolean present_username = true && (isSetUsername()); + list.add(present_username); + if (present_username) + list.add(username); - private static class restartFailed_resultTupleScheme extends TupleScheme<restartFailed_result> { + boolean present_password = true && (isSetPassword()); + list.add(present_password); + if (present_password) + list.add(password); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, restartFailed_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + return list.hashCode(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, restartFailed_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + @Override + public int compareTo(getUserData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - } + int lastComparison = 0; - public static class isCaptchaWaiting_args implements org.apache.thrift.TBase<isCaptchaWaiting_args, isCaptchaWaiting_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isCaptchaWaiting_args"); + lastComparison = Boolean.valueOf(isSetUsername()).compareTo(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 = Boolean.valueOf(isSetPassword()).compareTo(other.isSetPassword()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPassword()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, other.password); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isCaptchaWaiting_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isCaptchaWaiting_argsTupleSchemeFactory()); - } + 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); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isCaptchaWaiting_args.class, metaDataMap); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getUserData_args("); + boolean first = true; - public isCaptchaWaiting_args() { - } + sb.append("username:"); + if (this.username == null) { + sb.append("null"); + } else { + sb.append(this.username); + } + first = false; + if (!first) sb.append(", "); + sb.append("password:"); + if (this.password == null) { + sb.append("null"); + } else { + sb.append(this.password); + } + first = false; + sb.append(")"); + return sb.toString(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isCaptchaWaiting_args(isCaptchaWaiting_args other) { - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public isCaptchaWaiting_args deepCopy() { - return new isCaptchaWaiting_args(this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public void clear() { - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + private static class getUserData_argsStandardSchemeFactory implements SchemeFactory { + public getUserData_argsStandardScheme getScheme() { + return new getUserData_argsStandardScheme(); + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + private static class getUserData_argsStandardScheme extends StandardScheme<getUserData_args> { - /** 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(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getUserData_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: // 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: // PASSWORD + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(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(); - switch (field) { - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isCaptchaWaiting_args) - return this.equals((isCaptchaWaiting_args)that); - return false; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getUserData_args struct) throws org.apache.thrift.TException { + struct.validate(); - public boolean equals(isCaptchaWaiting_args that) { - if (that == null) - return false; + oprot.writeStructBegin(STRUCT_DESC); + if (struct.username != null) { + oprot.writeFieldBegin(USERNAME_FIELD_DESC); + oprot.writeString(struct.username); + oprot.writeFieldEnd(); + } + if (struct.password != null) { + oprot.writeFieldBegin(PASSWORD_FIELD_DESC); + oprot.writeString(struct.password); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - return true; - } + } - @Override - public int hashCode() { - return 0; - } + private static class getUserData_argsTupleSchemeFactory implements SchemeFactory { + public getUserData_argsTupleScheme getScheme() { + return new getUserData_argsTupleScheme(); + } + } - public int compareTo(isCaptchaWaiting_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + private static class getUserData_argsTupleScheme extends TupleScheme<getUserData_args> { - int lastComparison = 0; - isCaptchaWaiting_args typedOther = (isCaptchaWaiting_args)other; + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getUserData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetUsername()) { + optionals.set(0); + } + if (struct.isSetPassword()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetUsername()) { + oprot.writeString(struct.username); + } + if (struct.isSetPassword()) { + oprot.writeString(struct.password); + } + } - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getUserData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.username = iprot.readString(); + struct.setUsernameIsSet(true); + } + if (incoming.get(1)) { + struct.password = iprot.readString(); + struct.setPasswordIsSet(true); + } + } + } - 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 static class getUserData_result implements org.apache.thrift.TBase<getUserData_result, getUserData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getUserData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserData_result"); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("isCaptchaWaiting_args("); - boolean first = true; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - sb.append(")"); - return sb.toString(); - } + static { + schemes.put(StandardScheme.class, new getUserData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getUserData_resultTupleSchemeFactory()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public UserData success; // required - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } - 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.getMessage()); - } - } + @Override + public int describeContents() { + return 0; + } - private static class isCaptchaWaiting_argsStandardSchemeFactory implements SchemeFactory { - public isCaptchaWaiting_argsStandardScheme getScheme() { - return new isCaptchaWaiting_argsStandardScheme(); - } - } + public getUserData_result(android.os.Parcel in) { + this.success = in.readParcelable(getUserData_result.class.getClassLoader()); + } - private static class isCaptchaWaiting_argsStandardScheme extends StandardScheme<isCaptchaWaiting_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isCaptchaWaiting_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, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public static final android.os.Parcelable.Creator<getUserData_result> CREATOR = new android.os.Parcelable.Creator<getUserData_result>() { + @Override + public getUserData_result[] newArray(int size) { + return new getUserData_result[size]; + } - } + @Override + public getUserData_result createFromParcel(android.os.Parcel in) { + return new getUserData_result(in); + } + }; - private static class isCaptchaWaiting_argsTupleSchemeFactory implements SchemeFactory { - public isCaptchaWaiting_argsTupleScheme getScheme() { - return new isCaptchaWaiting_argsTupleScheme(); - } - } + /** 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 class isCaptchaWaiting_argsTupleScheme extends TupleScheme<isCaptchaWaiting_args> { + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + 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; + } - public static class isCaptchaWaiting_result implements org.apache.thrift.TBase<isCaptchaWaiting_result, isCaptchaWaiting_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isCaptchaWaiting_result"); + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - 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 final short _thriftId; + private final String _fieldName; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new isCaptchaWaiting_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new isCaptchaWaiting_resultTupleSchemeFactory()); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public boolean 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 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 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 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; - } - } + public short getThriftFieldId() { + return _thriftId; + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isCaptchaWaiting_result.class, metaDataMap); - } + public String getFieldName() { + return _fieldName; + } + } - public isCaptchaWaiting_result() { - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public isCaptchaWaiting_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserData.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserData_result.class, metaDataMap); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public isCaptchaWaiting_result(isCaptchaWaiting_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + public getUserData_result() { + } - public isCaptchaWaiting_result deepCopy() { - return new isCaptchaWaiting_result(this); - } + public getUserData_result( + UserData success) { + this(); + this.success = success; + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getUserData_result(getUserData_result other) { + if (other.isSetSuccess()) { + this.success = new UserData(other.success); + } + } - public boolean isSuccess() { - return this.success; - } + public getUserData_result deepCopy() { + return new getUserData_result(this); + } - public isCaptchaWaiting_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + @Override + public void clear() { + this.success = null; + } - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + public UserData getSuccess() { + return this.success; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + public getUserData_result setSuccess(UserData success) { + this.success = success; + return this; + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + public void unsetSuccess() { + this.success = null; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; } - break; - } - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((UserData) value); + } + break; - } - throw new IllegalStateException(); - } + } + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof isCaptchaWaiting_result) - return this.equals((isCaptchaWaiting_result)that); - return false; - } + } + throw new IllegalStateException(); + } - public boolean equals(isCaptchaWaiting_result that) { - if (that == null) - return false; + /** 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(); + } - 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; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - return true; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getUserData_result) + return this.equals((getUserData_result) that); + return false; + } - @Override - public int hashCode() { - return 0; - } + public boolean equals(getUserData_result that) { + if (that == null) + return false; - public int compareTo(isCaptchaWaiting_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - isCaptchaWaiting_result typedOther = (isCaptchaWaiting_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + 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; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + return true; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("isCaptchaWaiting_result("); - boolean first = true; + return list.hashCode(); + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public int compareTo(getUserData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + int lastComparison = 0; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - 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.getMessage()); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class isCaptchaWaiting_resultStandardSchemeFactory implements SchemeFactory { - public isCaptchaWaiting_resultStandardScheme getScheme() { - return new isCaptchaWaiting_resultStandardScheme(); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private static class isCaptchaWaiting_resultStandardScheme extends StandardScheme<isCaptchaWaiting_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, isCaptchaWaiting_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; - 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, isCaptchaWaiting_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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("getUserData_result("); + boolean first = true; - private static class isCaptchaWaiting_resultTupleSchemeFactory implements SchemeFactory { - public isCaptchaWaiting_resultTupleScheme getScheme() { - return new isCaptchaWaiting_resultTupleScheme(); - } - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class isCaptchaWaiting_resultTupleScheme extends TupleScheme<isCaptchaWaiting_result> { + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (success != null) { + success.validate(); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); + + 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); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + private static class getUserData_resultStandardSchemeFactory implements SchemeFactory { + public getUserData_resultStandardScheme getScheme() { + return new getUserData_resultStandardScheme(); + } } - } - } - } + private static class getUserData_resultStandardScheme extends StandardScheme<getUserData_result> { - public static class getCaptchaTask_args implements org.apache.thrift.TBase<getCaptchaTask_args, getCaptchaTask_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTask_args"); + public void read(org.apache.thrift.protocol.TProtocol iprot, getUserData_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 UserData(); + struct.success.read(iprot); + 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(); - private static final org.apache.thrift.protocol.TField EXCLUSIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("exclusive", org.apache.thrift.protocol.TType.BOOL, (short)1); + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCaptchaTask_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCaptchaTask_argsTupleSchemeFactory()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getUserData_result struct) throws org.apache.thrift.TException { + struct.validate(); - public boolean exclusive; // 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 { - EXCLUSIVE((short)1, "exclusive"); - - 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: // EXCLUSIVE - return EXCLUSIVE; - 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; - } - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - // isset id assignments - private static final int __EXCLUSIVE_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.EXCLUSIVE, new org.apache.thrift.meta_data.FieldMetaData("exclusive", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTask_args.class, metaDataMap); - } + } - public getCaptchaTask_args() { - } + private static class getUserData_resultTupleSchemeFactory implements SchemeFactory { + public getUserData_resultTupleScheme getScheme() { + return new getUserData_resultTupleScheme(); + } + } - public getCaptchaTask_args( - boolean exclusive) - { - this(); - this.exclusive = exclusive; - setExclusiveIsSet(true); - } + private static class getUserData_resultTupleScheme extends TupleScheme<getUserData_result> { - /** - * Performs a deep copy on <i>other</i>. - */ - public getCaptchaTask_args(getCaptchaTask_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.exclusive = other.exclusive; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getUserData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } - public getCaptchaTask_args deepCopy() { - return new getCaptchaTask_args(this); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getUserData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new UserData(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } - @Override - public void clear() { - setExclusiveIsSet(false); - this.exclusive = false; } - public boolean isExclusive() { - return this.exclusive; - } + public static class getAllUserData_args implements org.apache.thrift.TBase<getAllUserData_args, getAllUserData_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAllUserData_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllUserData_args"); - public getCaptchaTask_args setExclusive(boolean exclusive) { - this.exclusive = exclusive; - setExclusiveIsSet(true); - return this; - } - public void unsetExclusive() { - __isset_bit_vector.clear(__EXCLUSIVE_ISSET_ID); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** Returns true if field exclusive is set (has been assigned a value) and false otherwise */ - public boolean isSetExclusive() { - return __isset_bit_vector.get(__EXCLUSIVE_ISSET_ID); - } + static { + schemes.put(StandardScheme.class, new getAllUserData_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAllUserData_argsTupleSchemeFactory()); + } - public void setExclusiveIsSet(boolean value) { - __isset_bit_vector.set(__EXCLUSIVE_ISSET_ID, value); - } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case EXCLUSIVE: - if (value == null) { - unsetExclusive(); - } else { - setExclusive((Boolean)value); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - break; - } - } + @Override + public int describeContents() { + return 0; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case EXCLUSIVE: - return Boolean.valueOf(isExclusive()); + public getAllUserData_args(android.os.Parcel in) { + } - } - throw new IllegalStateException(); - } + public static final android.os.Parcelable.Creator<getAllUserData_args> CREATOR = new android.os.Parcelable.Creator<getAllUserData_args>() { + @Override + public getAllUserData_args[] newArray(int size) { + return new getAllUserData_args[size]; + } - /** 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 EXCLUSIVE: - return isSetExclusive(); - } - throw new IllegalStateException(); - } + @Override + public getAllUserData_args createFromParcel(android.os.Parcel in) { + return new getAllUserData_args(in); + } + }; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCaptchaTask_args) - return this.equals((getCaptchaTask_args)that); - return false; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public boolean equals(getCaptchaTask_args that) { - if (that == null) - return false; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - boolean this_present_exclusive = true; - boolean that_present_exclusive = true; - if (this_present_exclusive || that_present_exclusive) { - if (!(this_present_exclusive && that_present_exclusive)) - return false; - if (this.exclusive != that.exclusive) - return false; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - return true; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - @Override - public int hashCode() { - return 0; - } + /** + * 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; + } - public int compareTo(getCaptchaTask_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCaptchaTask_args typedOther = (getCaptchaTask_args)other; - - lastComparison = Boolean.valueOf(isSetExclusive()).compareTo(typedOther.isSetExclusive()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetExclusive()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.exclusive, typedOther.exclusive); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private final short _thriftId; + private final String _fieldName; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getCaptchaTask_args("); - boolean first = true; + public String getFieldName() { + return _fieldName; + } + } - sb.append("exclusive:"); - sb.append(this.exclusive); - first = false; - sb.append(")"); - return sb.toString(); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllUserData_args.class, metaDataMap); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public getAllUserData_args() { + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAllUserData_args(getAllUserData_args other) { + } - private static class getCaptchaTask_argsStandardSchemeFactory implements SchemeFactory { - public getCaptchaTask_argsStandardScheme getScheme() { - return new getCaptchaTask_argsStandardScheme(); - } - } + public getAllUserData_args deepCopy() { + return new getAllUserData_args(this); + } - private static class getCaptchaTask_argsStandardScheme extends StandardScheme<getCaptchaTask_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTask_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: // EXCLUSIVE - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.exclusive = iprot.readBool(); - struct.setExclusiveIsSet(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, getCaptchaTask_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(EXCLUSIVE_FIELD_DESC); - oprot.writeBool(struct.exclusive); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public void clear() { + } - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - private static class getCaptchaTask_argsTupleSchemeFactory implements SchemeFactory { - public getCaptchaTask_argsTupleScheme getScheme() { - return new getCaptchaTask_argsTupleScheme(); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - private static class getCaptchaTask_argsTupleScheme extends TupleScheme<getCaptchaTask_args> { + /** 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(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetExclusive()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetExclusive()) { - oprot.writeBool(struct.exclusive); + switch (field) { + } + throw new IllegalStateException(); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.exclusive = iprot.readBool(); - struct.setExclusiveIsSet(true); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAllUserData_args) + return this.equals((getAllUserData_args) that); + return false; } - } - } - } + public boolean equals(getAllUserData_args that) { + if (that == null) + return false; - public static class getCaptchaTask_result implements org.apache.thrift.TBase<getCaptchaTask_result, getCaptchaTask_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTask_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); + return true; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCaptchaTask_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCaptchaTask_resultTupleSchemeFactory()); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public CaptchaTask 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 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 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 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; - } - } + return list.hashCode(); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CaptchaTask.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTask_result.class, metaDataMap); - } + @Override + public int compareTo(getAllUserData_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getCaptchaTask_result() { - } + int lastComparison = 0; - public getCaptchaTask_result( - CaptchaTask success) - { - this(); - this.success = success; - } + return 0; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getCaptchaTask_result(getCaptchaTask_result other) { - if (other.isSetSuccess()) { - this.success = new CaptchaTask(other.success); - } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public getCaptchaTask_result deepCopy() { - return new getCaptchaTask_result(this); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - @Override - public void clear() { - this.success = null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public CaptchaTask getSuccess() { - return this.success; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAllUserData_args("); + boolean first = true; - public getCaptchaTask_result setSuccess(CaptchaTask success) { - this.success = success; - return this; - } + sb.append(")"); + return sb.toString(); + } - public void unsetSuccess() { - this.success = null; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((CaptchaTask)value); + private static class getAllUserData_argsStandardSchemeFactory implements SchemeFactory { + public getAllUserData_argsStandardScheme getScheme() { + return new getAllUserData_argsStandardScheme(); + } } - break; - } - } + private static class getAllUserData_argsStandardScheme extends StandardScheme<getAllUserData_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void read(org.apache.thrift.protocol.TProtocol iprot, getAllUserData_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(); - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAllUserData_args struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCaptchaTask_result) - return this.equals((getCaptchaTask_result)that); - return false; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public boolean equals(getCaptchaTask_result that) { - if (that == null) - return false; + } - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } + private static class getAllUserData_argsTupleSchemeFactory implements SchemeFactory { + public getAllUserData_argsTupleScheme getScheme() { + return new getAllUserData_argsTupleScheme(); + } + } - return true; - } + private static class getAllUserData_argsTupleScheme extends TupleScheme<getAllUserData_args> { - @Override - public int hashCode() { - return 0; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAllUserData_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - public int compareTo(getCaptchaTask_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCaptchaTask_result typedOther = (getCaptchaTask_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAllUserData_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - 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 static class getAllUserData_result implements org.apache.thrift.TBase<getAllUserData_result, getAllUserData_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAllUserData_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllUserData_result"); - 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("getCaptchaTask_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(); - } + 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); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + schemes.put(StandardScheme.class, new getAllUserData_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAllUserData_resultTupleSchemeFactory()); + } - 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.getMessage()); - } - } + public Map<String, UserData> success; // required - private static class getCaptchaTask_resultStandardSchemeFactory implements SchemeFactory { - public getCaptchaTask_resultStandardScheme getScheme() { - return new getCaptchaTask_resultStandardScheme(); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } - private static class getCaptchaTask_resultStandardScheme extends StandardScheme<getCaptchaTask_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTask_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 CaptchaTask(); - struct.success.read(iprot); - 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, getCaptchaTask_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public int describeContents() { + return 0; + } - } + public getAllUserData_result(android.os.Parcel in) { + this.success = new HashMap<String, UserData>(); + in.readMap(this.success, getAllUserData_result.class.getClassLoader()); + } - private static class getCaptchaTask_resultTupleSchemeFactory implements SchemeFactory { - public getCaptchaTask_resultTupleScheme getScheme() { - return new getCaptchaTask_resultTupleScheme(); - } - } + public static final android.os.Parcelable.Creator<getAllUserData_result> CREATOR = new android.os.Parcelable.Creator<getAllUserData_result>() { + @Override + public getAllUserData_result[] newArray(int size) { + return new getAllUserData_result[size]; + } - private static class getCaptchaTask_resultTupleScheme extends TupleScheme<getCaptchaTask_result> { + @Override + public getAllUserData_result createFromParcel(android.os.Parcel in) { + return new getAllUserData_result(in); + } + }; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); - } - } + /** 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"); - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new CaptchaTask(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); - } - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public static class getCaptchaTaskStatus_args implements org.apache.thrift.TBase<getCaptchaTaskStatus_args, getCaptchaTaskStatus_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTaskStatus_args"); + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I32, (short)1); + /** + * 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; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCaptchaTaskStatus_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCaptchaTaskStatus_argsTupleSchemeFactory()); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public int tid; // 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 { - TID((short)1, "tid"); - - 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: // TID - return TID; - 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; - } - } + private final short _thriftId; + private final String _fieldName; - // isset id assignments - private static final int __TID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "TaskID"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTaskStatus_args.class, metaDataMap); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public getCaptchaTaskStatus_args() { - } + public short getThriftFieldId() { + return _thriftId; + } - public getCaptchaTaskStatus_args( - int tid) - { - this(); - this.tid = tid; - setTidIsSet(true); - } + public String getFieldName() { + return _fieldName; + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getCaptchaTaskStatus_args(getCaptchaTaskStatus_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.tid = other.tid; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public getCaptchaTaskStatus_args deepCopy() { - return new getCaptchaTaskStatus_args(this); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserData.class)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllUserData_result.class, metaDataMap); + } - @Override - public void clear() { - setTidIsSet(false); - this.tid = 0; - } + public getAllUserData_result() { + } + + public getAllUserData_result( + Map<String, UserData> success) { + this(); + this.success = success; + } - public int getTid() { - return this.tid; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAllUserData_result(getAllUserData_result other) { + if (other.isSetSuccess()) { + Map<String, UserData> __this__success = new HashMap<String, UserData>(other.success.size()); + for (Map.Entry<String, UserData> other_element : other.success.entrySet()) { - public getCaptchaTaskStatus_args setTid(int tid) { - this.tid = tid; - setTidIsSet(true); - return this; - } + String other_element_key = other_element.getKey(); + UserData other_element_value = other_element.getValue(); - public void unsetTid() { - __isset_bit_vector.clear(__TID_ISSET_ID); - } + String __this__success_copy_key = other_element_key; - /** Returns true if field tid is set (has been assigned a value) and false otherwise */ - public boolean isSetTid() { - return __isset_bit_vector.get(__TID_ISSET_ID); - } + UserData __this__success_copy_value = new UserData(other_element_value); - public void setTidIsSet(boolean value) { - __isset_bit_vector.set(__TID_ISSET_ID, value); - } + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case TID: - if (value == null) { - unsetTid(); - } else { - setTid((Integer)value); + public getAllUserData_result deepCopy() { + return new getAllUserData_result(this); } - break; - } - } + @Override + public void clear() { + this.success = null; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case TID: - return Integer.valueOf(getTid()); + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - } - throw new IllegalStateException(); - } + public void putToSuccess(String key, UserData val) { + if (this.success == null) { + this.success = new HashMap<String, UserData>(); + } + this.success.put(key, val); + } - /** 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 TID: - return isSetTid(); - } - throw new IllegalStateException(); - } + public Map<String, UserData> getSuccess() { + return this.success; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCaptchaTaskStatus_args) - return this.equals((getCaptchaTaskStatus_args)that); - return false; - } + public getAllUserData_result setSuccess(Map<String, UserData> success) { + this.success = success; + return this; + } - public boolean equals(getCaptchaTaskStatus_args that) { - if (that == null) - return false; + public void unsetSuccess() { + this.success = null; + } - boolean this_present_tid = true; - boolean that_present_tid = true; - if (this_present_tid || that_present_tid) { - if (!(this_present_tid && that_present_tid)) - return false; - if (this.tid != that.tid) - return false; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - return true; - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - @Override - public int hashCode() { - return 0; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, UserData>) value); + } + break; - public int compareTo(getCaptchaTaskStatus_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCaptchaTaskStatus_args typedOther = (getCaptchaTaskStatus_args)other; - - lastComparison = Boolean.valueOf(isSetTid()).compareTo(typedOther.isSetTid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, typedOther.tid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + } + throw new IllegalStateException(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** 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(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getCaptchaTaskStatus_args("); - boolean first = true; + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - sb.append("tid:"); - sb.append(this.tid); - first = false; - sb.append(")"); - return sb.toString(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAllUserData_result) + return this.equals((getAllUserData_result) that); + return false; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public boolean equals(getAllUserData_result that) { + if (that == null) + return false; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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; + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return true; + } - private static class getCaptchaTaskStatus_argsStandardSchemeFactory implements SchemeFactory { - public getCaptchaTaskStatus_argsStandardScheme getScheme() { - return new getCaptchaTaskStatus_argsStandardScheme(); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class getCaptchaTaskStatus_argsStandardScheme extends StandardScheme<getCaptchaTaskStatus_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTaskStatus_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: // TID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.tid = iprot.readI32(); - struct.setTidIsSet(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, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(TID_FIELD_DESC); - oprot.writeI32(struct.tid); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - } + return list.hashCode(); + } - private static class getCaptchaTaskStatus_argsTupleSchemeFactory implements SchemeFactory { - public getCaptchaTaskStatus_argsTupleScheme getScheme() { - return new getCaptchaTaskStatus_argsTupleScheme(); - } - } + @Override + public int compareTo(getAllUserData_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class getCaptchaTaskStatus_argsTupleScheme extends TupleScheme<getCaptchaTaskStatus_args> { + int lastComparison = 0; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetTid()) { - optionals.set(0); + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; } - oprot.writeBitSet(optionals, 1); - if (struct.isSetTid()) { - oprot.writeI32(struct.tid); + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.tid = iprot.readI32(); - struct.setTidIsSet(true); + 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); + } - public static class getCaptchaTaskStatus_result implements org.apache.thrift.TBase<getCaptchaTaskStatus_result, getCaptchaTaskStatus_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTaskStatus_result"); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAllUserData_result("); + boolean first = true; - 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); + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getCaptchaTaskStatus_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getCaptchaTaskStatus_resultTupleSchemeFactory()); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public 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 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 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 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; - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTaskStatus_result.class, metaDataMap); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public getCaptchaTaskStatus_result() { - } + private static class getAllUserData_resultStandardSchemeFactory implements SchemeFactory { + public getAllUserData_resultStandardScheme getScheme() { + return new getAllUserData_resultStandardScheme(); + } + } - public getCaptchaTaskStatus_result( - String success) - { - this(); - this.success = success; - } + private static class getAllUserData_resultStandardScheme extends StandardScheme<getAllUserData_result> { - /** - * Performs a deep copy on <i>other</i>. - */ - public getCaptchaTaskStatus_result(getCaptchaTaskStatus_result other) { - if (other.isSetSuccess()) { - this.success = other.success; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAllUserData_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 _map374 = iprot.readMapBegin(); + struct.success = new HashMap<String, UserData>(2 * _map374.size); + String _key375; + UserData _val376; + for (int _i377 = 0; _i377 < _map374.size; ++_i377) { + _key375 = iprot.readString(); + _val376 = new UserData(); + _val376.read(iprot); + struct.success.put(_key375, _val376); + } + iprot.readMapEnd(); + } + 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(); - public getCaptchaTaskStatus_result deepCopy() { - return new getCaptchaTaskStatus_result(this); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void clear() { - this.success = null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAllUserData_result struct) throws org.apache.thrift.TException { + struct.validate(); - public String getSuccess() { - return this.success; - } + 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 (Map.Entry<String, UserData> _iter378 : struct.success.entrySet()) { + oprot.writeString(_iter378.getKey()); + _iter378.getValue().write(oprot); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public getCaptchaTaskStatus_result setSuccess(String success) { - this.success = success; - return this; - } + } - public void unsetSuccess() { - this.success = null; - } + private static class getAllUserData_resultTupleSchemeFactory implements SchemeFactory { + public getAllUserData_resultTupleScheme getScheme() { + return new getAllUserData_resultTupleScheme(); + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + private static class getAllUserData_resultTupleScheme extends TupleScheme<getAllUserData_result> { - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAllUserData_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, UserData> _iter379 : struct.success.entrySet()) { + oprot.writeString(_iter379.getKey()); + _iter379.getValue().write(oprot); + } + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((String)value); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAllUserData_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map380 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); + struct.success = new HashMap<String, UserData>(2 * _map380.size); + String _key381; + UserData _val382; + for (int _i383 = 0; _i383 < _map380.size; ++_i383) { + _key381 = iprot.readString(); + _val382 = new UserData(); + _val382.read(iprot); + struct.success.put(_key381, _val382); + } + } + struct.setSuccessIsSet(true); + } + } } - break; - } } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public static class getServices_args implements org.apache.thrift.TBase<getServices_args, getServices_args._Fields>, java.io.Serializable, Cloneable, Comparable<getServices_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServices_args"); - } - throw new IllegalStateException(); - } - - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getCaptchaTaskStatus_result) - return this.equals((getCaptchaTaskStatus_result)that); - return false; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public boolean equals(getCaptchaTaskStatus_result that) { - if (that == null) - return false; + static { + schemes.put(StandardScheme.class, new getServices_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getServices_argsTupleSchemeFactory()); + } - 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 void writeToParcel(android.os.Parcel out, int flags) { + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(getCaptchaTaskStatus_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getCaptchaTaskStatus_result typedOther = (getCaptchaTaskStatus_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public getServices_args(android.os.Parcel in) { + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static final android.os.Parcelable.Creator<getServices_args> CREATOR = new android.os.Parcelable.Creator<getServices_args>() { + @Override + public getServices_args[] newArray(int size) { + return new getServices_args[size]; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public getServices_args createFromParcel(android.os.Parcel in) { + return new getServices_args(in); + } + }; - 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("getCaptchaTaskStatus_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(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + ; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - private static class getCaptchaTaskStatus_resultStandardSchemeFactory implements SchemeFactory { - public getCaptchaTaskStatus_resultStandardScheme getScheme() { - return new getCaptchaTaskStatus_resultStandardScheme(); - } - } + /** + * 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; + } - private static class getCaptchaTaskStatus_resultStandardScheme extends StandardScheme<getCaptchaTaskStatus_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTaskStatus_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, getCaptchaTaskStatus_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(); - } + /** + * 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; - private static class getCaptchaTaskStatus_resultTupleSchemeFactory implements SchemeFactory { - public getCaptchaTaskStatus_resultTupleScheme getScheme() { - return new getCaptchaTaskStatus_resultTupleScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class getCaptchaTaskStatus_resultTupleScheme extends TupleScheme<getCaptchaTaskStatus_result> { + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeString(struct.success); + public String getFieldName() { + return _fieldName; + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readString(); - struct.setSuccessIsSet(true); - } - } - } + 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); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServices_args.class, metaDataMap); + } - public static class setCaptchaResult_args implements org.apache.thrift.TBase<setCaptchaResult_args, setCaptchaResult_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setCaptchaResult_args"); + public getServices_args() { + } - private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I32, (short)1); - private static final org.apache.thrift.protocol.TField RESULT_FIELD_DESC = new org.apache.thrift.protocol.TField("result", org.apache.thrift.protocol.TType.STRING, (short)2); + /** + * Performs a deep copy on <i>other</i>. + */ + public getServices_args(getServices_args other) { + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setCaptchaResult_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setCaptchaResult_argsTupleSchemeFactory()); - } + public getServices_args deepCopy() { + return new getServices_args(this); + } - public int tid; // required - public String result; // 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 { - TID((short)1, "tid"), - RESULT((short)2, "result"); - - 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: // TID - return TID; - case 2: // RESULT - return RESULT; - 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; - } - } + @Override + public void clear() { + } - // isset id assignments - private static final int __TID_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32 , "TaskID"))); - tmpMap.put(_Fields.RESULT, new org.apache.thrift.meta_data.FieldMetaData("result", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setCaptchaResult_args.class, metaDataMap); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public setCaptchaResult_args() { - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public setCaptchaResult_args( - int tid, - String result) - { - this(); - this.tid = tid; - setTidIsSet(true); - this.result = result; - } + /** 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(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public setCaptchaResult_args(setCaptchaResult_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.tid = other.tid; - if (other.isSetResult()) { - this.result = other.result; - } - } + switch (field) { + } + throw new IllegalStateException(); + } - public setCaptchaResult_args deepCopy() { - return new setCaptchaResult_args(this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getServices_args) + return this.equals((getServices_args) that); + return false; + } - @Override - public void clear() { - setTidIsSet(false); - this.tid = 0; - this.result = null; - } + public boolean equals(getServices_args that) { + if (that == null) + return false; - public int getTid() { - return this.tid; - } + return true; + } - public setCaptchaResult_args setTid(int tid) { - this.tid = tid; - setTidIsSet(true); - return this; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void unsetTid() { - __isset_bit_vector.clear(__TID_ISSET_ID); - } + return list.hashCode(); + } - /** Returns true if field tid is set (has been assigned a value) and false otherwise */ - public boolean isSetTid() { - return __isset_bit_vector.get(__TID_ISSET_ID); - } + @Override + public int compareTo(getServices_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void setTidIsSet(boolean value) { - __isset_bit_vector.set(__TID_ISSET_ID, value); - } + int lastComparison = 0; - public String getResult() { - return this.result; - } + return 0; + } - public setCaptchaResult_args setResult(String result) { - this.result = result; - return this; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void unsetResult() { - this.result = null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - /** Returns true if field result is set (has been assigned a value) and false otherwise */ - public boolean isSetResult() { - return this.result != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void setResultIsSet(boolean value) { - if (!value) { - this.result = null; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getServices_args("); + boolean first = true; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case TID: - if (value == null) { - unsetTid(); - } else { - setTid((Integer)value); + sb.append(")"); + return sb.toString(); } - break; - case RESULT: - if (value == null) { - unsetResult(); - } else { - setResult((String)value); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - break; - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case TID: - return Integer.valueOf(getTid()); - - case RESULT: - return getResult(); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - } - throw new IllegalStateException(); - } + 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); + } + } - /** 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 TID: - return isSetTid(); - case RESULT: - return isSetResult(); - } - throw new IllegalStateException(); - } + private static class getServices_argsStandardSchemeFactory implements SchemeFactory { + public getServices_argsStandardScheme getScheme() { + return new getServices_argsStandardScheme(); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setCaptchaResult_args) - return this.equals((setCaptchaResult_args)that); - return false; - } + private static class getServices_argsStandardScheme extends StandardScheme<getServices_args> { - public boolean equals(setCaptchaResult_args that) { - if (that == null) - return false; - - boolean this_present_tid = true; - boolean that_present_tid = true; - if (this_present_tid || that_present_tid) { - if (!(this_present_tid && that_present_tid)) - return false; - if (this.tid != that.tid) - return false; - } - - boolean this_present_result = true && this.isSetResult(); - boolean that_present_result = true && that.isSetResult(); - if (this_present_result || that_present_result) { - if (!(this_present_result && that_present_result)) - return false; - if (!this.result.equals(that.result)) - return false; - } - - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getServices_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(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(setCaptchaResult_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - setCaptchaResult_args typedOther = (setCaptchaResult_args)other; - - lastComparison = Boolean.valueOf(isSetTid()).compareTo(typedOther.isSetTid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, typedOther.tid); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetResult()).compareTo(typedOther.isSetResult()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetResult()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.result, typedOther.result); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getServices_args struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class getServices_argsTupleSchemeFactory implements SchemeFactory { + public getServices_argsTupleScheme getScheme() { + return new getServices_argsTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setCaptchaResult_args("); - boolean first = true; - - sb.append("tid:"); - sb.append(this.tid); - first = false; - if (!first) sb.append(", "); - sb.append("result:"); - if (this.result == null) { - sb.append("null"); - } else { - sb.append(this.result); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private static class getServices_argsTupleScheme extends TupleScheme<getServices_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getServices_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getServices_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } } - private static class setCaptchaResult_argsStandardSchemeFactory implements SchemeFactory { - public setCaptchaResult_argsStandardScheme getScheme() { - return new setCaptchaResult_argsStandardScheme(); - } - } + public static class getServices_result implements org.apache.thrift.TBase<getServices_result, getServices_result._Fields>, java.io.Serializable, Cloneable, Comparable<getServices_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServices_result"); - private static class setCaptchaResult_argsStandardScheme extends StandardScheme<setCaptchaResult_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setCaptchaResult_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: // TID - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.tid = iprot.readI32(); - struct.setTidIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // RESULT - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.result = iprot.readString(); - struct.setResultIsSet(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, setCaptchaResult_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(TID_FIELD_DESC); - oprot.writeI32(struct.tid); - oprot.writeFieldEnd(); - if (struct.result != null) { - oprot.writeFieldBegin(RESULT_FIELD_DESC); - oprot.writeString(struct.result); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class setCaptchaResult_argsTupleSchemeFactory implements SchemeFactory { - public setCaptchaResult_argsTupleScheme getScheme() { - return new setCaptchaResult_argsTupleScheme(); - } - } + static { + schemes.put(StandardScheme.class, new getServices_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getServices_resultTupleSchemeFactory()); + } - private static class setCaptchaResult_argsTupleScheme extends TupleScheme<setCaptchaResult_args> { + public Map<String, Map<String, String>> success; // required - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetTid()) { - optionals.set(0); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); } - if (struct.isSetResult()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetTid()) { - oprot.writeI32(struct.tid); - } - if (struct.isSetResult()) { - oprot.writeString(struct.result); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.tid = iprot.readI32(); - struct.setTidIsSet(true); - } - if (incoming.get(1)) { - struct.result = iprot.readString(); - struct.setResultIsSet(true); + @Override + public int describeContents() { + return 0; } - } - } - - } - - public static class setCaptchaResult_result implements org.apache.thrift.TBase<setCaptchaResult_result, setCaptchaResult_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setCaptchaResult_result"); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new setCaptchaResult_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new setCaptchaResult_resultTupleSchemeFactory()); - } + public getServices_result(android.os.Parcel in) { + this.success = new HashMap<String, Map<String, String>>(); + in.readMap(this.success, getServices_result.class.getClassLoader()); + } + public static final android.os.Parcelable.Creator<getServices_result> CREATOR = new android.os.Parcelable.Creator<getServices_result>() { + @Override + public getServices_result[] newArray(int size) { + return new getServices_result[size]; + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setCaptchaResult_result.class, metaDataMap); - } + @Override + public getServices_result createFromParcel(android.os.Parcel in) { + return new getServices_result(in); + } + }; - public setCaptchaResult_result() { - } + /** 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"); - /** - * Performs a deep copy on <i>other</i>. - */ - public setCaptchaResult_result(setCaptchaResult_result other) { - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public setCaptchaResult_result deepCopy() { - return new setCaptchaResult_result(this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public void clear() { - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + /** + * 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; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** 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(); - } + private final short _thriftId; + private final String _fieldName; - switch (field) { - } - throw new IllegalStateException(); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof setCaptchaResult_result) - return this.equals((setCaptchaResult_result)that); - return false; - } + public short getThriftFieldId() { + return _thriftId; + } - public boolean equals(setCaptchaResult_result that) { - if (that == null) - return false; + public String getFieldName() { + return _fieldName; + } + } - return true; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - @Override - public int hashCode() { - return 0; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"), + 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(getServices_result.class, metaDataMap); + } - public int compareTo(setCaptchaResult_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public getServices_result() { + } - int lastComparison = 0; - setCaptchaResult_result typedOther = (setCaptchaResult_result)other; + public getServices_result( + Map<String, Map<String, String>> success) { + this(); + this.success = success; + } - return 0; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getServices_result(getServices_result other) { + if (other.isSetSuccess()) { + Map<String, Map<String, String>> __this__success = new HashMap<String, Map<String, String>>(other.success.size()); + for (Map.Entry<String, Map<String, String>> other_element : other.success.entrySet()) { - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + String other_element_key = other_element.getKey(); + Map<String, String> other_element_value = other_element.getValue(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + String __this__success_copy_key = other_element_key; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + Map<String, String> __this__success_copy_value = new HashMap<String, String>(other_element_value); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("setCaptchaResult_result("); - boolean first = true; + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } - sb.append(")"); - return sb.toString(); - } + public getServices_result deepCopy() { + return new getServices_result(this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void clear() { + this.success = null; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - 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.getMessage()); - } - } + public void putToSuccess(String key, Map<String, String> val) { + if (this.success == null) { + this.success = new HashMap<String, Map<String, String>>(); + } + this.success.put(key, val); + } - private static class setCaptchaResult_resultStandardSchemeFactory implements SchemeFactory { - public setCaptchaResult_resultStandardScheme getScheme() { - return new setCaptchaResult_resultStandardScheme(); - } - } + public Map<String, Map<String, String>> getSuccess() { + return this.success; + } - private static class setCaptchaResult_resultStandardScheme extends StandardScheme<setCaptchaResult_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, setCaptchaResult_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) { - 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, setCaptchaResult_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public getServices_result setSuccess(Map<String, Map<String, String>> success) { + this.success = success; + return this; + } - } + public void unsetSuccess() { + this.success = null; + } - private static class setCaptchaResult_resultTupleSchemeFactory implements SchemeFactory { - public setCaptchaResult_resultTupleScheme getScheme() { - return new setCaptchaResult_resultTupleScheme(); - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - private static class setCaptchaResult_resultTupleScheme extends TupleScheme<setCaptchaResult_result> { + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, Map<String, String>>) value); + } + break; - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + } + } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public static class getEvents_args implements org.apache.thrift.TBase<getEvents_args, getEvents_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getEvents_args"); + } + throw new IllegalStateException(); + } - private static final org.apache.thrift.protocol.TField UUID_FIELD_DESC = new org.apache.thrift.protocol.TField("uuid", org.apache.thrift.protocol.TType.STRING, (short)1); + /** 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getEvents_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getEvents_argsTupleSchemeFactory()); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public String uuid; // 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 { - UUID((short)1, "uuid"); - - 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: // UUID - return UUID; - 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; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getServices_result) + return this.equals((getServices_result) that); + return false; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.UUID, new org.apache.thrift.meta_data.FieldMetaData("uuid", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getEvents_args.class, metaDataMap); - } + public boolean equals(getServices_result that) { + if (that == null) + return false; - public getEvents_args() { - } + 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; + } - public getEvents_args( - String uuid) - { - this(); - this.uuid = uuid; - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getEvents_args(getEvents_args other) { - if (other.isSetUuid()) { - this.uuid = other.uuid; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public getEvents_args deepCopy() { - return new getEvents_args(this); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - @Override - public void clear() { - this.uuid = null; - } + return list.hashCode(); + } - public String getUuid() { - return this.uuid; - } + @Override + public int compareTo(getServices_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getEvents_args setUuid(String uuid) { - this.uuid = uuid; - return this; - } + int lastComparison = 0; - public void unsetUuid() { - this.uuid = null; - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - /** Returns true if field uuid is set (has been assigned a value) and false otherwise */ - public boolean isSetUuid() { - return this.uuid != null; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setUuidIsSet(boolean value) { - if (!value) { - this.uuid = null; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case UUID: - if (value == null) { - unsetUuid(); - } else { - setUuid((String)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getServices_result("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case UUID: - return getUuid(); + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** 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 UUID: - return isSetUuid(); - } - throw new IllegalStateException(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getEvents_args) - return this.equals((getEvents_args)that); - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(getEvents_args that) { - if (that == null) - return false; + private static class getServices_resultStandardSchemeFactory implements SchemeFactory { + public getServices_resultStandardScheme getScheme() { + return new getServices_resultStandardScheme(); + } + } - boolean this_present_uuid = true && this.isSetUuid(); - boolean that_present_uuid = true && that.isSetUuid(); - if (this_present_uuid || that_present_uuid) { - if (!(this_present_uuid && that_present_uuid)) - return false; - if (!this.uuid.equals(that.uuid)) - return false; - } + private static class getServices_resultStandardScheme extends StandardScheme<getServices_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getServices_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 _map384 = iprot.readMapBegin(); + struct.success = new HashMap<String, Map<String, String>>(2 * _map384.size); + String _key385; + Map<String, String> _val386; + for (int _i387 = 0; _i387 < _map384.size; ++_i387) { + _key385 = iprot.readString(); + { + org.apache.thrift.protocol.TMap _map388 = iprot.readMapBegin(); + _val386 = new HashMap<String, String>(2 * _map388.size); + String _key389; + String _val390; + for (int _i391 = 0; _i391 < _map388.size; ++_i391) { + _key389 = iprot.readString(); + _val390 = iprot.readString(); + _val386.put(_key389, _val390); + } + iprot.readMapEnd(); + } + struct.success.put(_key385, _val386); + } + iprot.readMapEnd(); + } + 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(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(getEvents_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getEvents_args typedOther = (getEvents_args)other; - - lastComparison = Boolean.valueOf(isSetUuid()).compareTo(typedOther.isSetUuid()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUuid()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.uuid, typedOther.uuid); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getServices_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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.MAP, struct.success.size())); + for (Map.Entry<String, Map<String, String>> _iter392 : struct.success.entrySet()) { + oprot.writeString(_iter392.getKey()); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter392.getValue().size())); + for (Map.Entry<String, String> _iter393 : _iter392.getValue().entrySet()) { + oprot.writeString(_iter393.getKey()); + oprot.writeString(_iter393.getValue()); + } + oprot.writeMapEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class getServices_resultTupleSchemeFactory implements SchemeFactory { + public getServices_resultTupleScheme getScheme() { + return new getServices_resultTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getEvents_args("); - boolean first = true; - - sb.append("uuid:"); - if (this.uuid == null) { - sb.append("null"); - } else { - sb.append(this.uuid); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private static class getServices_resultTupleScheme extends TupleScheme<getServices_result> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getServices_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, Map<String, String>> _iter394 : struct.success.entrySet()) { + oprot.writeString(_iter394.getKey()); + { + oprot.writeI32(_iter394.getValue().size()); + for (Map.Entry<String, String> _iter395 : _iter394.getValue().entrySet()) { + oprot.writeString(_iter395.getKey()); + oprot.writeString(_iter395.getValue()); + } + } + } + } + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getServices_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map396 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32()); + struct.success = new HashMap<String, Map<String, String>>(2 * _map396.size); + String _key397; + Map<String, String> _val398; + for (int _i399 = 0; _i399 < _map396.size; ++_i399) { + _key397 = iprot.readString(); + { + org.apache.thrift.protocol.TMap _map400 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val398 = new HashMap<String, String>(2 * _map400.size); + String _key401; + String _val402; + for (int _i403 = 0; _i403 < _map400.size; ++_i403) { + _key401 = iprot.readString(); + _val402 = iprot.readString(); + _val398.put(_key401, _val402); + } + } + struct.success.put(_key397, _val398); + } + } + struct.setSuccessIsSet(true); + } + } + } - 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.getMessage()); - } } - private static class getEvents_argsStandardSchemeFactory implements SchemeFactory { - public getEvents_argsStandardScheme getScheme() { - return new getEvents_argsStandardScheme(); - } - } + public static class hasService_args implements org.apache.thrift.TBase<hasService_args, hasService_args._Fields>, java.io.Serializable, Cloneable, Comparable<hasService_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasService_args"); - private static class getEvents_argsStandardScheme extends StandardScheme<getEvents_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getEvents_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: // UUID - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.uuid = iprot.readString(); - struct.setUuidIsSet(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, getEvents_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.uuid != null) { - oprot.writeFieldBegin(UUID_FIELD_DESC); - oprot.writeString(struct.uuid); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short) 2); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - private static class getEvents_argsTupleSchemeFactory implements SchemeFactory { - public getEvents_argsTupleScheme getScheme() { - return new getEvents_argsTupleScheme(); - } - } + static { + schemes.put(StandardScheme.class, new hasService_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new hasService_argsTupleSchemeFactory()); + } - private static class getEvents_argsTupleScheme extends TupleScheme<getEvents_args> { + public String plugin; // required + public String func; // required - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getEvents_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUuid()) { - optionals.set(0); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(plugin); + out.writeString(func); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetUuid()) { - oprot.writeString(struct.uuid); + + @Override + public int describeContents() { + return 0; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getEvents_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.uuid = iprot.readString(); - struct.setUuidIsSet(true); + public hasService_args(android.os.Parcel in) { + this.plugin = in.readString(); + this.func = in.readString(); } - } - } - } + public static final android.os.Parcelable.Creator<hasService_args> CREATOR = new android.os.Parcelable.Creator<hasService_args>() { + @Override + public hasService_args[] newArray(int size) { + return new hasService_args[size]; + } - public static class getEvents_result implements org.apache.thrift.TBase<getEvents_result, getEvents_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getEvents_result"); + @Override + public hasService_args createFromParcel(android.os.Parcel in) { + return new hasService_args(in); + } + }; - 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); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"), + FUNC((short) 2, "func"); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getEvents_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getEvents_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public List<EventInfo> 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 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 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 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, EventInfo.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getEvents_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PLUGIN + return PLUGIN; + case 2: // FUNC + return FUNC; + default: + return null; + } + } - public getEvents_result() { - } + /** + * 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; + } - public getEvents_result( - List<EventInfo> success) - { - this(); - this.success = success; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getEvents_result(getEvents_result other) { - if (other.isSetSuccess()) { - List<EventInfo> __this__success = new ArrayList<EventInfo>(); - for (EventInfo other_element : other.success) { - __this__success.add(new EventInfo(other_element)); - } - this.success = __this__success; - } - } + private final short _thriftId; + private final String _fieldName; - public getEvents_result deepCopy() { - return new getEvents_result(this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void clear() { - this.success = null; - } + public short getThriftFieldId() { + return _thriftId; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public String getFieldName() { + return _fieldName; + } + } - public java.util.Iterator<EventInfo> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void addToSuccess(EventInfo elem) { - if (this.success == null) { - this.success = new ArrayList<EventInfo>(); - } - this.success.add(elem); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasService_args.class, metaDataMap); + } - public List<EventInfo> getSuccess() { - return this.success; - } + public hasService_args() { + } - public getEvents_result setSuccess(List<EventInfo> success) { - this.success = success; - return this; - } + public hasService_args( + String plugin, + String func) { + this(); + this.plugin = plugin; + this.func = func; + } - public void unsetSuccess() { - this.success = null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public hasService_args(hasService_args other) { + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetFunc()) { + this.func = other.func; + } + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public hasService_args deepCopy() { + return new hasService_args(this); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public void clear() { + this.plugin = null; + this.func = null; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<EventInfo>)value); + public String getPlugin() { + return this.plugin; } - break; - } - } + public hasService_args setPlugin(String plugin) { + this.plugin = plugin; + return this; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + public void unsetPlugin() { + this.plugin = null; + } - } - throw new IllegalStateException(); - } + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getEvents_result) - return this.equals((getEvents_result)that); - return false; - } + public String getFunc() { + return this.func; + } - public boolean equals(getEvents_result that) { - if (that == null) - return false; + public hasService_args setFunc(String func) { + this.func = func; + return this; + } - 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; - } + public void unsetFunc() { + this.func = null; + } - return true; - } + /** Returns true if field func is set (has been assigned a value) and false otherwise */ + public boolean isSetFunc() { + return this.func != null; + } - @Override - public int hashCode() { - return 0; - } + public void setFuncIsSet(boolean value) { + if (!value) { + this.func = null; + } + } - public int compareTo(getEvents_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getEvents_result typedOther = (getEvents_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + case FUNC: + if (value == null) { + unsetFunc(); + } else { + setFunc((String) value); + } + break; - 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("getEvents_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 Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + case FUNC: + return getFunc(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + } + throw new IllegalStateException(); + } - 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.getMessage()); - } - } + /** 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(); + } - private static class getEvents_resultStandardSchemeFactory implements SchemeFactory { - public getEvents_resultStandardScheme getScheme() { - return new getEvents_resultStandardScheme(); - } - } + switch (field) { + case PLUGIN: + return isSetPlugin(); + case FUNC: + return isSetFunc(); + } + throw new IllegalStateException(); + } - private static class getEvents_resultStandardScheme extends StandardScheme<getEvents_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getEvents_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 _list316 = iprot.readListBegin(); - struct.success = new ArrayList<EventInfo>(_list316.size); - for (int _i317 = 0; _i317 < _list316.size; ++_i317) - { - EventInfo _elem318; // required - _elem318 = new EventInfo(); - _elem318.read(iprot); - struct.success.add(_elem318); - } - iprot.readListEnd(); - } - 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, getEvents_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 (EventInfo _iter319 : struct.success) - { - _iter319.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof hasService_args) + return this.equals((hasService_args) that); + return false; + } - } + public boolean equals(hasService_args that) { + if (that == null) + return false; - private static class getEvents_resultTupleSchemeFactory implements SchemeFactory { - public getEvents_resultTupleScheme getScheme() { - return new getEvents_resultTupleScheme(); - } - } + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } - private static class getEvents_resultTupleScheme extends TupleScheme<getEvents_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getEvents_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (EventInfo _iter320 : struct.success) - { - _iter320.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getEvents_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list321 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<EventInfo>(_list321.size); - for (int _i322 = 0; _i322 < _list321.size; ++_i322) - { - EventInfo _elem323; // required - _elem323 = new EventInfo(); - _elem323.read(iprot); - struct.success.add(_elem323); - } - } - struct.setSuccessIsSet(true); - } - } - } + boolean this_present_func = true && this.isSetFunc(); + boolean that_present_func = true && that.isSetFunc(); + if (this_present_func || that_present_func) { + if (!(this_present_func && that_present_func)) + return false; + if (!this.func.equals(that.func)) + return false; + } - } + return true; + } - public static class getAccounts_args implements org.apache.thrift.TBase<getAccounts_args, getAccounts_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccounts_args"); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static final org.apache.thrift.protocol.TField REFRESH_FIELD_DESC = new org.apache.thrift.protocol.TField("refresh", org.apache.thrift.protocol.TType.BOOL, (short)1); + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAccounts_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAccounts_argsTupleSchemeFactory()); - } + boolean present_func = true && (isSetFunc()); + list.add(present_func); + if (present_func) + list.add(func); - public boolean refresh; // 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 { - REFRESH((short)1, "refresh"); - - 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: // REFRESH - return REFRESH; - 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; - } - } + return list.hashCode(); + } - // isset id assignments - private static final int __REFRESH_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.REFRESH, new org.apache.thrift.meta_data.FieldMetaData("refresh", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccounts_args.class, metaDataMap); - } + @Override + public int compareTo(hasService_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getAccounts_args() { - } + int lastComparison = 0; - public getAccounts_args( - boolean refresh) - { - this(); - this.refresh = refresh; - setRefreshIsSet(true); - } + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetFunc()).compareTo(other.isSetFunc()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFunc()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, other.func); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAccounts_args(getAccounts_args other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.refresh = other.refresh; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public getAccounts_args deepCopy() { - return new getAccounts_args(this); - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - @Override - public void clear() { - setRefreshIsSet(false); - this.refresh = false; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public boolean isRefresh() { - return this.refresh; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("hasService_args("); + boolean first = true; - public getAccounts_args setRefresh(boolean refresh) { - this.refresh = refresh; - setRefreshIsSet(true); - return this; - } + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("func:"); + if (this.func == null) { + sb.append("null"); + } else { + sb.append(this.func); + } + first = false; + sb.append(")"); + return sb.toString(); + } - public void unsetRefresh() { - __isset_bit_vector.clear(__REFRESH_ISSET_ID); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field refresh is set (has been assigned a value) and false otherwise */ - public boolean isSetRefresh() { - return __isset_bit_vector.get(__REFRESH_ISSET_ID); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setRefreshIsSet(boolean value) { - __isset_bit_vector.set(__REFRESH_ISSET_ID, value); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case REFRESH: - if (value == null) { - unsetRefresh(); - } else { - setRefresh((Boolean)value); + private static class hasService_argsStandardSchemeFactory implements SchemeFactory { + public hasService_argsStandardScheme getScheme() { + return new hasService_argsStandardScheme(); + } } - break; - } - } + private static class hasService_argsStandardScheme extends StandardScheme<hasService_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - case REFRESH: - return Boolean.valueOf(isRefresh()); + public void read(org.apache.thrift.protocol.TProtocol iprot, hasService_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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // FUNC + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.func = iprot.readString(); + struct.setFuncIsSet(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(); - } - throw new IllegalStateException(); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** 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 REFRESH: - return isSetRefresh(); - } - throw new IllegalStateException(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, hasService_args struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAccounts_args) - return this.equals((getAccounts_args)that); - return false; - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.func != null) { + oprot.writeFieldBegin(FUNC_FIELD_DESC); + oprot.writeString(struct.func); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public boolean equals(getAccounts_args that) { - if (that == null) - return false; + } - boolean this_present_refresh = true; - boolean that_present_refresh = true; - if (this_present_refresh || that_present_refresh) { - if (!(this_present_refresh && that_present_refresh)) - return false; - if (this.refresh != that.refresh) - return false; - } + private static class hasService_argsTupleSchemeFactory implements SchemeFactory { + public hasService_argsTupleScheme getScheme() { + return new hasService_argsTupleScheme(); + } + } - return true; - } + private static class hasService_argsTupleScheme extends TupleScheme<hasService_args> { - @Override - public int hashCode() { - return 0; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, hasService_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + if (struct.isSetFunc()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetFunc()) { + oprot.writeString(struct.func); + } + } - public int compareTo(getAccounts_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getAccounts_args typedOther = (getAccounts_args)other; - - lastComparison = Boolean.valueOf(isSetRefresh()).compareTo(typedOther.isSetRefresh()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetRefresh()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.refresh, typedOther.refresh); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, hasService_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(1)) { + struct.func = iprot.readString(); + struct.setFuncIsSet(true); + } + } + } - 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 static class hasService_result implements org.apache.thrift.TBase<hasService_result, hasService_result._Fields>, java.io.Serializable, Cloneable, Comparable<hasService_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasService_result"); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + 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); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getAccounts_args("); - boolean first = true; + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - sb.append("refresh:"); - sb.append(this.refresh); - first = false; - sb.append(")"); - return sb.toString(); - } + static { + schemes.put(StandardScheme.class, new hasService_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new hasService_resultTupleSchemeFactory()); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public boolean success; // required - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + out.writeInt(success ? 1 : 0); + } - private static class getAccounts_argsStandardSchemeFactory implements SchemeFactory { - public getAccounts_argsStandardScheme getScheme() { - return new getAccounts_argsStandardScheme(); - } - } + @Override + public int describeContents() { + return 0; + } - private static class getAccounts_argsStandardScheme extends StandardScheme<getAccounts_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAccounts_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: // REFRESH - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.refresh = iprot.readBool(); - struct.setRefreshIsSet(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, getAccounts_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(REFRESH_FIELD_DESC); - oprot.writeBool(struct.refresh); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public hasService_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - } + this.success = (in.readInt() == 1); + } - private static class getAccounts_argsTupleSchemeFactory implements SchemeFactory { - public getAccounts_argsTupleScheme getScheme() { - return new getAccounts_argsTupleScheme(); - } - } + public static final android.os.Parcelable.Creator<hasService_result> CREATOR = new android.os.Parcelable.Creator<hasService_result>() { + @Override + public hasService_result[] newArray(int size) { + return new hasService_result[size]; + } - private static class getAccounts_argsTupleScheme extends TupleScheme<getAccounts_args> { + @Override + public hasService_result createFromParcel(android.os.Parcel in) { + return new hasService_result(in); + } + }; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAccounts_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetRefresh()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetRefresh()) { - oprot.writeBool(struct.refresh); - } - } + /** 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"); - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAccounts_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.refresh = iprot.readBool(); - struct.setRefreshIsSet(true); - } - } - } + 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 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 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; - public static class getAccounts_result implements org.apache.thrift.TBase<getAccounts_result, getAccounts_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccounts_result"); + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - 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); + public short getThriftFieldId() { + return _thriftId; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAccounts_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAccounts_resultTupleSchemeFactory()); - } + public String getFieldName() { + return _fieldName; + } + } - public List<AccountInfo> 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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, AccountInfo.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccounts_result.class, metaDataMap); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasService_result.class, metaDataMap); + } - public getAccounts_result() { - } + public hasService_result() { + } - public getAccounts_result( - List<AccountInfo> success) - { - this(); - this.success = success; - } + public hasService_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAccounts_result(getAccounts_result other) { - if (other.isSetSuccess()) { - List<AccountInfo> __this__success = new ArrayList<AccountInfo>(); - for (AccountInfo other_element : other.success) { - __this__success.add(new AccountInfo(other_element)); - } - this.success = __this__success; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public hasService_result(hasService_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } - public getAccounts_result deepCopy() { - return new getAccounts_result(this); - } + public hasService_result deepCopy() { + return new hasService_result(this); + } - @Override - public void clear() { - this.success = null; - } + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public boolean isSuccess() { + return this.success; + } - public java.util.Iterator<AccountInfo> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + public hasService_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } - public void addToSuccess(AccountInfo elem) { - if (this.success == null) { - this.success = new ArrayList<AccountInfo>(); - } - this.success.add(elem); - } + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - public List<AccountInfo> getSuccess() { - return this.success; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - public getAccounts_result setSuccess(List<AccountInfo> success) { - this.success = success; - return this; - } + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } - public void unsetSuccess() { - this.success = null; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; - /** 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 Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<AccountInfo>)value); + } + throw new IllegalStateException(); } - break; - } - } + /** 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(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - } - throw new IllegalStateException(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof hasService_result) + return this.equals((hasService_result) that); + return false; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public boolean equals(hasService_result that) { + if (that == null) + return false; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAccounts_result) - return this.equals((getAccounts_result)that); - return false; - } + 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; + } - public boolean equals(getAccounts_result that) { - if (that == null) - return false; + 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; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - return true; - } + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); - @Override - public int hashCode() { - return 0; - } + return list.hashCode(); + } - public int compareTo(getAccounts_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getAccounts_result typedOther = (getAccounts_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + @Override + public int compareTo(hasService_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + int lastComparison = 0; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - 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("getAccounts_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 _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - 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.getMessage()); - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("hasService_result("); + boolean first = true; - private static class getAccounts_resultStandardSchemeFactory implements SchemeFactory { - public getAccounts_resultStandardScheme getScheme() { - return new getAccounts_resultStandardScheme(); - } - } + sb.append("success:"); + sb.append(this.success); + first = false; + sb.append(")"); + return sb.toString(); + } - private static class getAccounts_resultStandardScheme extends StandardScheme<getAccounts_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAccounts_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 _list324 = iprot.readListBegin(); - struct.success = new ArrayList<AccountInfo>(_list324.size); - for (int _i325 = 0; _i325 < _list324.size; ++_i325) - { - AccountInfo _elem326; // required - _elem326 = new AccountInfo(); - _elem326.read(iprot); - struct.success.add(_elem326); - } - iprot.readListEnd(); - } - 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, getAccounts_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 (AccountInfo _iter327 : struct.success) - { - _iter327.write(oprot); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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 static class getAccounts_resultTupleSchemeFactory implements SchemeFactory { - public getAccounts_resultTupleScheme getScheme() { - return new getAccounts_resultTupleScheme(); - } - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 getAccounts_resultTupleScheme extends TupleScheme<getAccounts_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAccounts_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (AccountInfo _iter328 : struct.success) - { - _iter328.write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAccounts_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list329 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new ArrayList<AccountInfo>(_list329.size); - for (int _i330 = 0; _i330 < _list329.size; ++_i330) - { - AccountInfo _elem331; // required - _elem331 = new AccountInfo(); - _elem331.read(iprot); - struct.success.add(_elem331); - } - } - struct.setSuccessIsSet(true); - } - } - } + private static class hasService_resultStandardSchemeFactory implements SchemeFactory { + public hasService_resultStandardScheme getScheme() { + return new hasService_resultStandardScheme(); + } + } - } + private static class hasService_resultStandardScheme extends StandardScheme<hasService_result> { - public static class getAccountTypes_args implements org.apache.thrift.TBase<getAccountTypes_args, getAccountTypes_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccountTypes_args"); + public void read(org.apache.thrift.protocol.TProtocol iprot, hasService_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; + 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAccountTypes_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAccountTypes_argsTupleSchemeFactory()); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, hasService_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccountTypes_args.class, metaDataMap); - } + } - public getAccountTypes_args() { - } + private static class hasService_resultTupleSchemeFactory implements SchemeFactory { + public hasService_resultTupleScheme getScheme() { + return new hasService_resultTupleScheme(); + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAccountTypes_args(getAccountTypes_args other) { - } + private static class hasService_resultTupleScheme extends TupleScheme<hasService_result> { - public getAccountTypes_args deepCopy() { - return new getAccountTypes_args(this); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, hasService_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } - @Override - public void clear() { - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, hasService_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public static class call_args implements org.apache.thrift.TBase<call_args, call_args._Fields>, java.io.Serializable, Cloneable, Comparable<call_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("call_args"); - /** 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(); - } + 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); - switch (field) { - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAccountTypes_args) - return this.equals((getAccountTypes_args)that); - return false; - } + static { + schemes.put(StandardScheme.class, new call_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new call_argsTupleSchemeFactory()); + } - public boolean equals(getAccountTypes_args that) { - if (that == null) - return false; + public ServiceCall info; // required - return true; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(info, flags); + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(getAccountTypes_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public call_args(android.os.Parcel in) { + this.info = in.readParcelable(call_args.class.getClassLoader()); + } - int lastComparison = 0; - getAccountTypes_args typedOther = (getAccountTypes_args)other; + public static final android.os.Parcelable.Creator<call_args> CREATOR = new android.os.Parcelable.Creator<call_args>() { + @Override + public call_args[] newArray(int size) { + return new call_args[size]; + } - return 0; - } + @Override + public call_args createFromParcel(android.os.Parcel in) { + return new call_args(in); + } + }; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** 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"); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getAccountTypes_args("); - boolean first = true; + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // INFO + return INFO; + default: + return null; + } + } - sb.append(")"); - return sb.toString(); - } + /** + * 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; + } - public void validate() throws org.apache.thrift.TException { - // check for required 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 void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private final short _thriftId; + private final String _fieldName; - 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.getMessage()); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class getAccountTypes_argsStandardSchemeFactory implements SchemeFactory { - public getAccountTypes_argsStandardScheme getScheme() { - return new getAccountTypes_argsStandardScheme(); - } - } + public short getThriftFieldId() { + return _thriftId; + } - private static class getAccountTypes_argsStandardScheme extends StandardScheme<getAccountTypes_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAccountTypes_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, getAccountTypes_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public String getFieldName() { + return _fieldName; + } + } - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class getAccountTypes_argsTupleSchemeFactory implements SchemeFactory { - public getAccountTypes_argsTupleScheme getScheme() { - return new getAccountTypes_argsTupleScheme(); - } - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new 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.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ServiceCall.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(call_args.class, metaDataMap); + } - private static class getAccountTypes_argsTupleScheme extends TupleScheme<getAccountTypes_args> { + public call_args() { + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + public call_args( + ServiceCall info) { + this(); + this.info = info; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public call_args(call_args other) { + if (other.isSetInfo()) { + this.info = new ServiceCall(other.info); + } + } - } + public call_args deepCopy() { + return new call_args(this); + } - public static class getAccountTypes_result implements org.apache.thrift.TBase<getAccountTypes_result, getAccountTypes_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAccountTypes_result"); + @Override + public void clear() { + this.info = null; + } - 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); + public ServiceCall getInfo() { + return this.info; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAccountTypes_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAccountTypes_resultTupleSchemeFactory()); - } + public call_args setInfo(ServiceCall info) { + this.info = info; + return this; + } - public List<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 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 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 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; - } - } + public void unsetInfo() { + this.info = null; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAccountTypes_result.class, metaDataMap); - } + /** Returns true if field info is set (has been assigned a value) and false otherwise */ + public boolean isSetInfo() { + return this.info != null; + } - public getAccountTypes_result() { - } + public void setInfoIsSet(boolean value) { + if (!value) { + this.info = null; + } + } - public getAccountTypes_result( - List<String> success) - { - this(); - this.success = success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case INFO: + if (value == null) { + unsetInfo(); + } else { + setInfo((ServiceCall) value); + } + break; - /** - * Performs a deep copy on <i>other</i>. - */ - public getAccountTypes_result(getAccountTypes_result other) { - if (other.isSetSuccess()) { - List<String> __this__success = new ArrayList<String>(); - for (String other_element : other.success) { - __this__success.add(other_element); - } - this.success = __this__success; - } - } + } + } - public getAccountTypes_result deepCopy() { - return new getAccountTypes_result(this); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case INFO: + return getInfo(); - @Override - public void clear() { - this.success = null; - } + } + throw new IllegalStateException(); + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + /** 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(); + } - public java.util.Iterator<String> getSuccessIterator() { - return (this.success == null) ? null : this.success.iterator(); - } + switch (field) { + case INFO: + return isSetInfo(); + } + throw new IllegalStateException(); + } - public void addToSuccess(String elem) { - if (this.success == null) { - this.success = new ArrayList<String>(); - } - this.success.add(elem); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof call_args) + return this.equals((call_args) that); + return false; + } - public List<String> getSuccess() { - return this.success; - } + public boolean equals(call_args that) { + if (that == null) + return false; - public getAccountTypes_result setSuccess(List<String> success) { - this.success = success; - return this; - } + 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; + } - public void unsetSuccess() { - this.success = null; - } + return true; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + boolean present_info = true && (isSetInfo()); + list.add(present_info); + if (present_info) + list.add(info); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((List<String>)value); + return list.hashCode(); } - break; - } - } + @Override + public int compareTo(call_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + int lastComparison = 0; - } - throw new IllegalStateException(); - } + lastComparison = Boolean.valueOf(isSetInfo()).compareTo(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; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAccountTypes_result) - return this.equals((getAccountTypes_result)that); - return false; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public boolean equals(getAccountTypes_result that) { - if (that == null) - return false; + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - 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; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("call_args("); + boolean first = true; - return true; - } + sb.append("info:"); + if (this.info == null) { + sb.append("null"); + } else { + sb.append(this.info); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public int hashCode() { - return 0; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + if (info != null) { + info.validate(); + } + } - public int compareTo(getAccountTypes_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getAccountTypes_result typedOther = (getAccountTypes_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private static class call_argsStandardSchemeFactory implements SchemeFactory { + public call_argsStandardScheme getScheme() { + return new call_argsStandardScheme(); + } + } - 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("getAccountTypes_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(); - } + private static class call_argsStandardScheme extends StandardScheme<call_args> { - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public void read(org.apache.thrift.protocol.TProtocol iprot, call_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 ServiceCall(); + 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(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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.getMessage()); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, call_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class getAccountTypes_resultStandardSchemeFactory implements SchemeFactory { - public getAccountTypes_resultStandardScheme getScheme() { - return new getAccountTypes_resultStandardScheme(); - } - } + 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 getAccountTypes_resultStandardScheme extends StandardScheme<getAccountTypes_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAccountTypes_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 _list332 = iprot.readListBegin(); - struct.success = new ArrayList<String>(_list332.size); - for (int _i333 = 0; _i333 < _list332.size; ++_i333) - { - String _elem334; // required - _elem334 = iprot.readString(); - struct.success.add(_elem334); - } - iprot.readListEnd(); - } - 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, getAccountTypes_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 (String _iter335 : struct.success) - { - oprot.writeString(_iter335); - } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + } - } + private static class call_argsTupleSchemeFactory implements SchemeFactory { + public call_argsTupleScheme getScheme() { + return new call_argsTupleScheme(); + } + } - private static class getAccountTypes_resultTupleSchemeFactory implements SchemeFactory { - public getAccountTypes_resultTupleScheme getScheme() { - return new getAccountTypes_resultTupleScheme(); - } - } + private static class call_argsTupleScheme extends TupleScheme<call_args> { - private static class getAccountTypes_resultTupleScheme extends TupleScheme<getAccountTypes_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (String _iter336 : struct.success) - { - oprot.writeString(_iter336); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAccountTypes_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TList _list337 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new ArrayList<String>(_list337.size); - for (int _i338 = 0; _i338 < _list337.size; ++_i338) - { - String _elem339; // required - _elem339 = iprot.readString(); - struct.success.add(_elem339); - } - } - struct.setSuccessIsSet(true); - } - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, call_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetInfo()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetInfo()) { + struct.info.write(oprot); + } + } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, call_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.info = new ServiceCall(); + struct.info.read(iprot); + struct.setInfoIsSet(true); + } + } + } - public static class updateAccount_args implements org.apache.thrift.TBase<updateAccount_args, updateAccount_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateAccount_args"); + } - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ACCOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("account", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short)3); - private static final org.apache.thrift.protocol.TField OPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("options", org.apache.thrift.protocol.TType.MAP, (short)4); + public static class call_result implements org.apache.thrift.TBase<call_result, call_result._Fields>, java.io.Serializable, Cloneable, Comparable<call_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("call_result"); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new updateAccount_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new updateAccount_argsTupleSchemeFactory()); - } + 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.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short) 1); + private static final org.apache.thrift.protocol.TField E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short) 2); - public String plugin; // required - public String account; // required - public String password; // required - public Map<String,String> options; // 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 { - PLUGIN((short)1, "plugin"), - ACCOUNT((short)2, "account"), - PASSWORD((short)3, "password"), - OPTIONS((short)4, "options"); - - 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: // PLUGIN - return PLUGIN; - case 2: // ACCOUNT - return ACCOUNT; - case 3: // PASSWORD - return PASSWORD; - case 4: // OPTIONS - return OPTIONS; - 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; - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.ACCOUNT, new org.apache.thrift.meta_data.FieldMetaData("account", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.OPTIONS, new org.apache.thrift.meta_data.FieldMetaData("options", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateAccount_args.class, metaDataMap); - } + static { + schemes.put(StandardScheme.class, new call_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new call_resultTupleSchemeFactory()); + } - public updateAccount_args() { - } + public String success; // required + public ServiceDoesNotExists ex; // required + public ServiceException e; // required - public updateAccount_args( - String plugin, - String account, - String password, - Map<String,String> options) - { - this(); - this.plugin = plugin; - this.account = account; - this.password = password; - this.options = options; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(success); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public updateAccount_args(updateAccount_args other) { - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetAccount()) { - this.account = other.account; - } - if (other.isSetPassword()) { - this.password = other.password; - } - if (other.isSetOptions()) { - Map<String,String> __this__options = new HashMap<String,String>(); - for (Map.Entry<String, String> other_element : other.options.entrySet()) { - - String other_element_key = other_element.getKey(); - String other_element_value = other_element.getValue(); - - String __this__options_copy_key = other_element_key; - - String __this__options_copy_value = other_element_value; - - __this__options.put(__this__options_copy_key, __this__options_copy_value); - } - this.options = __this__options; - } - } + @Override + public int describeContents() { + return 0; + } - public updateAccount_args deepCopy() { - return new updateAccount_args(this); - } + public call_result(android.os.Parcel in) { + this.success = in.readString(); + } - @Override - public void clear() { - this.plugin = null; - this.account = null; - this.password = null; - this.options = null; - } + public static final android.os.Parcelable.Creator<call_result> CREATOR = new android.os.Parcelable.Creator<call_result>() { + @Override + public call_result[] newArray(int size) { + return new call_result[size]; + } - public String getPlugin() { - return this.plugin; - } + @Override + public call_result createFromParcel(android.os.Parcel in) { + return new call_result(in); + } + }; - public updateAccount_args setPlugin(String plugin) { - this.plugin = plugin; - return this; - } + /** 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"), + EX((short) 1, "ex"), + E((short) 2, "e"); - public void unsetPlugin() { - this.plugin = null; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + case 1: // EX + return EX; + case 2: // E + return E; + default: + return null; + } + } - public String getAccount() { - return this.account; - } + /** + * 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; + } - public updateAccount_args setAccount(String account) { - this.account = account; - return this; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void unsetAccount() { - this.account = null; - } + private final short _thriftId; + private final String _fieldName; - /** Returns true if field account is set (has been assigned a value) and false otherwise */ - public boolean isSetAccount() { - return this.account != null; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setAccountIsSet(boolean value) { - if (!value) { - this.account = null; - } - } + public short getThriftFieldId() { + return _thriftId; + } - public String getPassword() { - return this.password; - } + public String getFieldName() { + return _fieldName; + } + } - public updateAccount_args setPassword(String password) { - this.password = password; - return this; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void unsetPassword() { - this.password = null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(call_result.class, metaDataMap); + } - /** Returns true if field password is set (has been assigned a value) and false otherwise */ - public boolean isSetPassword() { - return this.password != null; - } + public call_result() { + } - public void setPasswordIsSet(boolean value) { - if (!value) { - this.password = null; - } - } + public call_result( + String success, + ServiceDoesNotExists ex, + ServiceException e) { + this(); + this.success = success; + this.ex = ex; + this.e = e; + } - public int getOptionsSize() { - return (this.options == null) ? 0 : this.options.size(); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public call_result(call_result other) { + if (other.isSetSuccess()) { + this.success = other.success; + } + if (other.isSetEx()) { + this.ex = new ServiceDoesNotExists(other.ex); + } + if (other.isSetE()) { + this.e = new ServiceException(other.e); + } + } - public void putToOptions(String key, String val) { - if (this.options == null) { - this.options = new HashMap<String,String>(); - } - this.options.put(key, val); - } + public call_result deepCopy() { + return new call_result(this); + } - public Map<String,String> getOptions() { - return this.options; - } + @Override + public void clear() { + this.success = null; + this.ex = null; + this.e = null; + } - public updateAccount_args setOptions(Map<String,String> options) { - this.options = options; - return this; - } + public String getSuccess() { + return this.success; + } - public void unsetOptions() { - this.options = null; - } + public call_result setSuccess(String success) { + this.success = success; + return this; + } - /** Returns true if field options is set (has been assigned a value) and false otherwise */ - public boolean isSetOptions() { - return this.options != null; - } + public void unsetSuccess() { + this.success = null; + } - public void setOptionsIsSet(boolean value) { - if (!value) { - this.options = 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 setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } } - break; - case ACCOUNT: - if (value == null) { - unsetAccount(); - } else { - setAccount((String)value); + public ServiceDoesNotExists getEx() { + return this.ex; } - break; - case PASSWORD: - if (value == null) { - unsetPassword(); - } else { - setPassword((String)value); + public call_result setEx(ServiceDoesNotExists ex) { + this.ex = ex; + return this; } - break; - case OPTIONS: - if (value == null) { - unsetOptions(); - } else { - setOptions((Map<String,String>)value); + public void unsetEx() { + this.ex = null; } - break; - } - } + /** Returns true if field ex is set (has been assigned a value) and false otherwise */ + public boolean isSetEx() { + return this.ex != null; + } - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); + public void setExIsSet(boolean value) { + if (!value) { + this.ex = null; + } + } - case ACCOUNT: - return getAccount(); + public ServiceException getE() { + return this.e; + } - case PASSWORD: - return getPassword(); + public call_result setE(ServiceException e) { + this.e = e; + return this; + } - case OPTIONS: - return getOptions(); + public void unsetE() { + this.e = null; + } - } - throw new IllegalStateException(); - } + /** Returns true if field e is set (has been assigned a value) and false otherwise */ + public boolean isSetE() { + return this.e != null; + } - /** 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 PLUGIN: - return isSetPlugin(); - case ACCOUNT: - return isSetAccount(); - case PASSWORD: - return isSetPassword(); - case OPTIONS: - return isSetOptions(); - } - throw new IllegalStateException(); - } + public void setEIsSet(boolean value) { + if (!value) { + this.e = null; + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof updateAccount_args) - return this.equals((updateAccount_args)that); - return false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((String) value); + } + break; - public boolean equals(updateAccount_args that) { - if (that == null) - return false; - - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; - } - - boolean this_present_account = true && this.isSetAccount(); - boolean that_present_account = true && that.isSetAccount(); - if (this_present_account || that_present_account) { - if (!(this_present_account && that_present_account)) - return false; - if (!this.account.equals(that.account)) - return false; - } - - boolean this_present_password = true && this.isSetPassword(); - boolean that_present_password = true && that.isSetPassword(); - if (this_present_password || that_present_password) { - if (!(this_present_password && that_present_password)) - return false; - if (!this.password.equals(that.password)) - return false; - } - - boolean this_present_options = true && this.isSetOptions(); - boolean that_present_options = true && that.isSetOptions(); - if (this_present_options || that_present_options) { - if (!(this_present_options && that_present_options)) - return false; - if (!this.options.equals(that.options)) - return false; - } - - return true; - } + case EX: + if (value == null) { + unsetEx(); + } else { + setEx((ServiceDoesNotExists) value); + } + break; - @Override - public int hashCode() { - return 0; - } + case E: + if (value == null) { + unsetE(); + } else { + setE((ServiceException) value); + } + break; - public int compareTo(updateAccount_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - updateAccount_args typedOther = (updateAccount_args)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetAccount()).compareTo(typedOther.isSetAccount()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetAccount()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.account, typedOther.account); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPassword()).compareTo(typedOther.isSetPassword()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPassword()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, typedOther.password); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetOptions()).compareTo(typedOther.isSetOptions()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetOptions()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.options, typedOther.options); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + case EX: + return getEx(); - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + case E: + return getE(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("updateAccount_args("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("account:"); - if (this.account == null) { - sb.append("null"); - } else { - sb.append(this.account); - } - first = false; - if (!first) sb.append(", "); - sb.append("password:"); - if (this.password == null) { - sb.append("null"); - } else { - sb.append(this.password); - } - first = false; - if (!first) sb.append(", "); - sb.append("options:"); - if (this.options == null) { - sb.append("null"); - } else { - sb.append(this.options); - } - first = false; - sb.append(")"); - return sb.toString(); - } + } + throw new IllegalStateException(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + /** 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(); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + case EX: + return isSetEx(); + case E: + return isSetE(); + } + throw new IllegalStateException(); + } - 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.getMessage()); - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof call_result) + return this.equals((call_result) that); + return false; + } - private static class updateAccount_argsStandardSchemeFactory implements SchemeFactory { - public updateAccount_argsStandardScheme getScheme() { - return new updateAccount_argsStandardScheme(); - } - } + public boolean equals(call_result that) { + if (that == null) + return false; - private static class updateAccount_argsStandardScheme extends StandardScheme<updateAccount_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, updateAccount_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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // ACCOUNT - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.account = iprot.readString(); - struct.setAccountIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 3: // PASSWORD - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 4: // OPTIONS - if (schemeField.type == org.apache.thrift.protocol.TType.MAP) { - { - org.apache.thrift.protocol.TMap _map340 = iprot.readMapBegin(); - struct.options = new HashMap<String,String>(2*_map340.size); - for (int _i341 = 0; _i341 < _map340.size; ++_i341) - { - String _key342; // required - String _val343; // required - _key342 = iprot.readString(); - _val343 = iprot.readString(); - struct.options.put(_key342, _val343); - } - iprot.readMapEnd(); - } - struct.setOptionsIsSet(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, updateAccount_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.account != null) { - oprot.writeFieldBegin(ACCOUNT_FIELD_DESC); - oprot.writeString(struct.account); - oprot.writeFieldEnd(); - } - if (struct.password != null) { - oprot.writeFieldBegin(PASSWORD_FIELD_DESC); - oprot.writeString(struct.password); - oprot.writeFieldEnd(); - } - if (struct.options != null) { - oprot.writeFieldBegin(OPTIONS_FIELD_DESC); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, struct.options.size())); - for (Map.Entry<String, String> _iter344 : struct.options.entrySet()) - { - oprot.writeString(_iter344.getKey()); - oprot.writeString(_iter344.getValue()); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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_ex = true && this.isSetEx(); + boolean that_present_ex = true && that.isSetEx(); + if (this_present_ex || that_present_ex) { + if (!(this_present_ex && that_present_ex)) + return false; + if (!this.ex.equals(that.ex)) + return false; + } - private static class updateAccount_argsTupleSchemeFactory implements SchemeFactory { - public updateAccount_argsTupleScheme getScheme() { - return new updateAccount_argsTupleScheme(); - } - } + boolean this_present_e = true && this.isSetE(); + boolean that_present_e = true && that.isSetE(); + if (this_present_e || that_present_e) { + if (!(this_present_e && that_present_e)) + return false; + if (!this.e.equals(that.e)) + return false; + } - private static class updateAccount_argsTupleScheme extends TupleScheme<updateAccount_args> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, updateAccount_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); - } - if (struct.isSetAccount()) { - optionals.set(1); - } - if (struct.isSetPassword()) { - optionals.set(2); - } - if (struct.isSetOptions()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetAccount()) { - oprot.writeString(struct.account); - } - if (struct.isSetPassword()) { - oprot.writeString(struct.password); - } - if (struct.isSetOptions()) { - { - oprot.writeI32(struct.options.size()); - for (Map.Entry<String, String> _iter345 : struct.options.entrySet()) - { - oprot.writeString(_iter345.getKey()); - oprot.writeString(_iter345.getValue()); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, updateAccount_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(1)) { - struct.account = iprot.readString(); - struct.setAccountIsSet(true); - } - if (incoming.get(2)) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); - } - if (incoming.get(3)) { - { - org.apache.thrift.protocol.TMap _map346 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.options = new HashMap<String,String>(2*_map346.size); - for (int _i347 = 0; _i347 < _map346.size; ++_i347) - { - String _key348; // required - String _val349; // required - _key348 = iprot.readString(); - _val349 = iprot.readString(); - struct.options.put(_key348, _val349); - } - } - struct.setOptionsIsSet(true); - } - } - } + return true; + } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public static class updateAccount_result implements org.apache.thrift.TBase<updateAccount_result, updateAccount_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("updateAccount_result"); + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); + boolean present_ex = true && (isSetEx()); + list.add(present_ex); + if (present_ex) + list.add(ex); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new updateAccount_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new updateAccount_resultTupleSchemeFactory()); - } + boolean present_e = true && (isSetE()); + list.add(present_e); + if (present_e) + list.add(e); + return list.hashCode(); + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(updateAccount_result.class, metaDataMap); - } + @Override + public int compareTo(call_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public updateAccount_result() { - } + int lastComparison = 0; - /** - * Performs a deep copy on <i>other</i>. - */ - public updateAccount_result(updateAccount_result other) { - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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 = Boolean.valueOf(isSetEx()).compareTo(other.isSetEx()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEx()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, other.ex); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetE()).compareTo(other.isSetE()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetE()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, other.e); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public updateAccount_result deepCopy() { - return new updateAccount_result(this); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public void clear() { - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("call_result("); + boolean first = true; - /** 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(); - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + if (!first) sb.append(", "); + sb.append("ex:"); + if (this.ex == null) { + sb.append("null"); + } else { + sb.append(this.ex); + } + first = false; + if (!first) sb.append(", "); + sb.append("e:"); + if (this.e == null) { + sb.append("null"); + } else { + sb.append(this.e); + } + first = false; + sb.append(")"); + return sb.toString(); + } - switch (field) { - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof updateAccount_result) - return this.equals((updateAccount_result)that); - return false; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(updateAccount_result that) { - if (that == null) - return false; + 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); + } + } - return true; - } + private static class call_resultStandardSchemeFactory implements SchemeFactory { + public call_resultStandardScheme getScheme() { + return new call_resultStandardScheme(); + } + } - @Override - public int hashCode() { - return 0; - } + private static class call_resultStandardScheme extends StandardScheme<call_result> { - public int compareTo(updateAccount_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, call_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; + case 1: // EX + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.ex = new ServiceDoesNotExists(); + struct.ex.read(iprot); + struct.setExIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // E + if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { + struct.e = new ServiceException(); + struct.e.read(iprot); + struct.setEIsSet(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(); - int lastComparison = 0; - updateAccount_result typedOther = (updateAccount_result)other; + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, call_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeString(struct.success); + oprot.writeFieldEnd(); + } + if (struct.ex != null) { + oprot.writeFieldBegin(EX_FIELD_DESC); + struct.ex.write(oprot); + oprot.writeFieldEnd(); + } + if (struct.e != null) { + oprot.writeFieldBegin(E_FIELD_DESC); + struct.e.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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); - } + private static class call_resultTupleSchemeFactory implements SchemeFactory { + public call_resultTupleScheme getScheme() { + return new call_resultTupleScheme(); + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("updateAccount_result("); - boolean first = true; + private static class call_resultTupleScheme extends TupleScheme<call_result> { - sb.append(")"); - return sb.toString(); - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, call_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + if (struct.isSetEx()) { + optionals.set(1); + } + if (struct.isSetE()) { + optionals.set(2); + } + oprot.writeBitSet(optionals, 3); + if (struct.isSetSuccess()) { + oprot.writeString(struct.success); + } + if (struct.isSetEx()) { + struct.ex.write(oprot); + } + if (struct.isSetE()) { + struct.e.write(oprot); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, call_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(3); + if (incoming.get(0)) { + struct.success = iprot.readString(); + struct.setSuccessIsSet(true); + } + if (incoming.get(1)) { + struct.ex = new ServiceDoesNotExists(); + struct.ex.read(iprot); + struct.setExIsSet(true); + } + if (incoming.get(2)) { + struct.e = new ServiceException(); + struct.e.read(iprot); + struct.setEIsSet(true); + } + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } } - 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.getMessage()); - } - } + public static class getAllInfo_args implements org.apache.thrift.TBase<getAllInfo_args, getAllInfo_args._Fields>, java.io.Serializable, Cloneable, Comparable<getAllInfo_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllInfo_args"); - private static class updateAccount_resultStandardSchemeFactory implements SchemeFactory { - public updateAccount_resultStandardScheme getScheme() { - return new updateAccount_resultStandardScheme(); - } - } - private static class updateAccount_resultStandardScheme extends StandardScheme<updateAccount_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, updateAccount_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) { - 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, updateAccount_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - } + static { + schemes.put(StandardScheme.class, new getAllInfo_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAllInfo_argsTupleSchemeFactory()); + } - private static class updateAccount_resultTupleSchemeFactory implements SchemeFactory { - public updateAccount_resultTupleScheme getScheme() { - return new updateAccount_resultTupleScheme(); - } - } - private static class updateAccount_resultTupleScheme extends TupleScheme<updateAccount_result> { + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, updateAccount_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public int describeContents() { + return 0; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, updateAccount_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public getAllInfo_args(android.os.Parcel in) { + } - } + public static final android.os.Parcelable.Creator<getAllInfo_args> CREATOR = new android.os.Parcelable.Creator<getAllInfo_args>() { + @Override + public getAllInfo_args[] newArray(int size) { + return new getAllInfo_args[size]; + } - public static class removeAccount_args implements org.apache.thrift.TBase<removeAccount_args, removeAccount_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("removeAccount_args"); + @Override + public getAllInfo_args createFromParcel(android.os.Parcel in) { + return new getAllInfo_args(in); + } + }; - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField ACCOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("account", org.apache.thrift.protocol.TType.STRING, (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 { + ; - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new removeAccount_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new removeAccount_argsTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public String plugin; // required - public String account; // 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 { - PLUGIN((short)1, "plugin"), - ACCOUNT((short)2, "account"); - - 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: // PLUGIN - return PLUGIN; - case 2: // ACCOUNT - return ACCOUNT; - 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.ACCOUNT, new org.apache.thrift.meta_data.FieldMetaData("account", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(removeAccount_args.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public removeAccount_args() { - } + /** + * 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; + } - public removeAccount_args( - String plugin, - String account) - { - this(); - this.plugin = plugin; - this.account = account; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public removeAccount_args(removeAccount_args other) { - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetAccount()) { - this.account = other.account; - } - } + private final short _thriftId; + private final String _fieldName; - public removeAccount_args deepCopy() { - return new removeAccount_args(this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void clear() { - this.plugin = null; - this.account = null; - } + public short getThriftFieldId() { + return _thriftId; + } - public String getPlugin() { - return this.plugin; - } + public String getFieldName() { + return _fieldName; + } + } - public removeAccount_args setPlugin(String plugin) { - this.plugin = plugin; - return this; - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void unsetPlugin() { - this.plugin = null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllInfo_args.class, metaDataMap); + } - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } + public getAllInfo_args() { + } - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAllInfo_args(getAllInfo_args other) { + } - public String getAccount() { - return this.account; - } + public getAllInfo_args deepCopy() { + return new getAllInfo_args(this); + } - public removeAccount_args setAccount(String account) { - this.account = account; - return this; - } + @Override + public void clear() { + } - public void unsetAccount() { - this.account = null; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - /** Returns true if field account is set (has been assigned a value) and false otherwise */ - public boolean isSetAccount() { - return this.account != null; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public void setAccountIsSet(boolean value) { - if (!value) { - this.account = null; - } - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); + switch (field) { + } + throw new IllegalStateException(); } - break; - case ACCOUNT: - if (value == null) { - unsetAccount(); - } else { - setAccount((String)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAllInfo_args) + return this.equals((getAllInfo_args) that); + return false; } - break; - } - } + public boolean equals(getAllInfo_args that) { + if (that == null) + return false; - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); + return true; + } - case ACCOUNT: - return getAccount(); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - } - throw new IllegalStateException(); - } + return list.hashCode(); + } - /** 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 PLUGIN: - return isSetPlugin(); - case ACCOUNT: - return isSetAccount(); - } - throw new IllegalStateException(); - } + @Override + public int compareTo(getAllInfo_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof removeAccount_args) - return this.equals((removeAccount_args)that); - return false; - } + int lastComparison = 0; - public boolean equals(removeAccount_args that) { - if (that == null) - return false; - - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; - } - - boolean this_present_account = true && this.isSetAccount(); - boolean that_present_account = true && that.isSetAccount(); - if (this_present_account || that_present_account) { - if (!(this_present_account && that_present_account)) - return false; - if (!this.account.equals(that.account)) - return false; - } - - return true; - } + return 0; + } - @Override - public int hashCode() { - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public int compareTo(removeAccount_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - removeAccount_args typedOther = (removeAccount_args)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetAccount()).compareTo(typedOther.isSetAccount()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetAccount()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.account, typedOther.account); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAllInfo_args("); + boolean first = true; - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + sb.append(")"); + return sb.toString(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("removeAccount_args("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("account:"); - if (this.account == null) { - sb.append("null"); - } else { - sb.append(this.account); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static class getAllInfo_argsStandardSchemeFactory implements SchemeFactory { + public getAllInfo_argsStandardScheme getScheme() { + return new getAllInfo_argsStandardScheme(); + } + } - private static class removeAccount_argsStandardSchemeFactory implements SchemeFactory { - public removeAccount_argsStandardScheme getScheme() { - return new removeAccount_argsStandardScheme(); - } - } + private static class getAllInfo_argsStandardScheme extends StandardScheme<getAllInfo_args> { - private static class removeAccount_argsStandardScheme extends StandardScheme<removeAccount_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, removeAccount_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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // ACCOUNT - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.account = iprot.readString(); - struct.setAccountIsSet(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, removeAccount_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.account != null) { - oprot.writeFieldBegin(ACCOUNT_FIELD_DESC); - oprot.writeString(struct.account); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAllInfo_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(); + } - private static class removeAccount_argsTupleSchemeFactory implements SchemeFactory { - public removeAccount_argsTupleScheme getScheme() { - return new removeAccount_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAllInfo_args struct) throws org.apache.thrift.TException { + struct.validate(); - private static class removeAccount_argsTupleScheme extends TupleScheme<removeAccount_args> { + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, removeAccount_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); - } - if (struct.isSetAccount()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); } - if (struct.isSetAccount()) { - oprot.writeString(struct.account); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, removeAccount_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(1)) { - struct.account = iprot.readString(); - struct.setAccountIsSet(true); + private static class getAllInfo_argsTupleSchemeFactory implements SchemeFactory { + public getAllInfo_argsTupleScheme getScheme() { + return new getAllInfo_argsTupleScheme(); + } } - } - } - } + private static class getAllInfo_argsTupleScheme extends TupleScheme<getAllInfo_args> { - public static class removeAccount_result implements org.apache.thrift.TBase<removeAccount_result, removeAccount_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("removeAccount_result"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAllInfo_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAllInfo_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new removeAccount_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new removeAccount_resultTupleSchemeFactory()); } + public static class getAllInfo_result implements org.apache.thrift.TBase<getAllInfo_result, getAllInfo_result._Fields>, java.io.Serializable, Cloneable, Comparable<getAllInfo_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllInfo_result"); - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(removeAccount_result.class, metaDataMap); - } + 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); - public removeAccount_result() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** - * Performs a deep copy on <i>other</i>. - */ - public removeAccount_result(removeAccount_result other) { - } + static { + schemes.put(StandardScheme.class, new getAllInfo_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getAllInfo_resultTupleSchemeFactory()); + } - public removeAccount_result deepCopy() { - return new removeAccount_result(this); - } + public Map<String, Map<String, String>> success; // required - @Override - public void clear() { - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + @Override + public int describeContents() { + return 0; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public getAllInfo_result(android.os.Parcel in) { + this.success = new HashMap<String, Map<String, String>>(); + in.readMap(this.success, getAllInfo_result.class.getClassLoader()); + } - /** 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(); - } + public static final android.os.Parcelable.Creator<getAllInfo_result> CREATOR = new android.os.Parcelable.Creator<getAllInfo_result>() { + @Override + public getAllInfo_result[] newArray(int size) { + return new getAllInfo_result[size]; + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public getAllInfo_result createFromParcel(android.os.Parcel in) { + return new getAllInfo_result(in); + } + }; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof removeAccount_result) - return this.equals((removeAccount_result)that); - return false; - } + /** 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"); - public boolean equals(removeAccount_result that) { - if (that == null) - return false; + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - return true; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - @Override - public int hashCode() { - return 0; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public int compareTo(removeAccount_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + /** + * 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; + } - int lastComparison = 0; - removeAccount_result typedOther = (removeAccount_result)other; + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - return 0; - } + private final short _thriftId; + private final String _fieldName; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public short getThriftFieldId() { + return _thriftId; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("removeAccount_result("); - boolean first = true; + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - sb.append(")"); - return sb.toString(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"), + 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(getAllInfo_result.class, metaDataMap); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public getAllInfo_result() { + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public getAllInfo_result( + Map<String, Map<String, String>> success) { + this(); + this.success = success; + } - 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.getMessage()); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getAllInfo_result(getAllInfo_result other) { + if (other.isSetSuccess()) { + Map<String, Map<String, String>> __this__success = new HashMap<String, Map<String, String>>(other.success.size()); + for (Map.Entry<String, Map<String, String>> other_element : other.success.entrySet()) { - private static class removeAccount_resultStandardSchemeFactory implements SchemeFactory { - public removeAccount_resultStandardScheme getScheme() { - return new removeAccount_resultStandardScheme(); - } - } + String other_element_key = other_element.getKey(); + Map<String, String> other_element_value = other_element.getValue(); - private static class removeAccount_resultStandardScheme extends StandardScheme<removeAccount_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, removeAccount_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) { - 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, removeAccount_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + String __this__success_copy_key = other_element_key; - } + Map<String, String> __this__success_copy_value = new HashMap<String, String>(other_element_value); - private static class removeAccount_resultTupleSchemeFactory implements SchemeFactory { - public removeAccount_resultTupleScheme getScheme() { - return new removeAccount_resultTupleScheme(); - } - } + __this__success.put(__this__success_copy_key, __this__success_copy_value); + } + this.success = __this__success; + } + } - private static class removeAccount_resultTupleScheme extends TupleScheme<removeAccount_result> { + public getAllInfo_result deepCopy() { + return new getAllInfo_result(this); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, removeAccount_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + @Override + public void clear() { + this.success = null; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, removeAccount_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - } + public void putToSuccess(String key, Map<String, String> val) { + if (this.success == null) { + this.success = new HashMap<String, Map<String, String>>(); + } + this.success.put(key, val); + } - public static class login_args implements org.apache.thrift.TBase<login_args, login_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("login_args"); + public Map<String, Map<String, String>> getSuccess() { + return this.success; + } - 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 PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short)2); + public getAllInfo_result setSuccess(Map<String, Map<String, String>> success) { + this.success = success; + return this; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new login_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new login_argsTupleSchemeFactory()); - } + public void unsetSuccess() { + this.success = null; + } - public String username; // required - public String password; // 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 { - USERNAME((short)1, "username"), - PASSWORD((short)2, "password"); - - 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: // USERNAME - return USERNAME; - case 2: // PASSWORD - return PASSWORD; - 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; - } - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.USERNAME, new org.apache.thrift.meta_data.FieldMetaData("username", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(login_args.class, metaDataMap); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - public login_args() { - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, Map<String, String>>) value); + } + break; - public login_args( - String username, - String password) - { - this(); - this.username = username; - this.password = password; - } + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public login_args(login_args other) { - if (other.isSetUsername()) { - this.username = other.username; - } - if (other.isSetPassword()) { - this.password = other.password; - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public login_args deepCopy() { - return new login_args(this); - } + } + throw new IllegalStateException(); + } - @Override - public void clear() { - this.username = null; - this.password = null; - } + /** 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(); + } - public String getUsername() { - return this.username; - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public login_args setUsername(String username) { - this.username = username; - return this; - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getAllInfo_result) + return this.equals((getAllInfo_result) that); + return false; + } - public void unsetUsername() { - this.username = null; - } + public boolean equals(getAllInfo_result that) { + if (that == null) + return false; - /** Returns true if field username is set (has been assigned a value) and false otherwise */ - public boolean isSetUsername() { - return this.username != null; - } + 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; + } - public void setUsernameIsSet(boolean value) { - if (!value) { - this.username = null; - } - } + return true; + } - public String getPassword() { - return this.password; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public login_args setPassword(String password) { - this.password = password; - return this; - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public void unsetPassword() { - this.password = null; - } + return list.hashCode(); + } - /** Returns true if field password is set (has been assigned a value) and false otherwise */ - public boolean isSetPassword() { - return this.password != null; - } + @Override + public int compareTo(getAllInfo_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void setPasswordIsSet(boolean value) { - if (!value) { - this.password = null; - } - } + int lastComparison = 0; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case USERNAME: - if (value == null) { - unsetUsername(); - } else { - setUsername((String)value); + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; } - break; - case PASSWORD: - if (value == null) { - unsetPassword(); - } else { - setPassword((String)value); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - break; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case USERNAME: - return getUsername(); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - case PASSWORD: - return getPassword(); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getAllInfo_result("); + boolean first = true; - } - throw new IllegalStateException(); - } + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - /** 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 USERNAME: - return isSetUsername(); - case PASSWORD: - return isSetPassword(); - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof login_args) - return this.equals((login_args)that); - return false; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(login_args that) { - if (that == null) - 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_password = true && this.isSetPassword(); - boolean that_present_password = true && that.isSetPassword(); - if (this_present_password || that_present_password) { - if (!(this_present_password && that_present_password)) - return false; - if (!this.password.equals(that.password)) - return false; - } - - return true; - } + 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); + } + } - @Override - public int hashCode() { - return 0; - } + private static class getAllInfo_resultStandardSchemeFactory implements SchemeFactory { + public getAllInfo_resultStandardScheme getScheme() { + return new getAllInfo_resultStandardScheme(); + } + } - public int compareTo(login_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - login_args typedOther = (login_args)other; - - lastComparison = Boolean.valueOf(isSetUsername()).compareTo(typedOther.isSetUsername()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUsername()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.username, typedOther.username); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPassword()).compareTo(typedOther.isSetPassword()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPassword()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, typedOther.password); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + private static class getAllInfo_resultStandardScheme extends StandardScheme<getAllInfo_result> { - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getAllInfo_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 _map404 = iprot.readMapBegin(); + struct.success = new HashMap<String, Map<String, String>>(2 * _map404.size); + String _key405; + Map<String, String> _val406; + for (int _i407 = 0; _i407 < _map404.size; ++_i407) { + _key405 = iprot.readString(); + { + org.apache.thrift.protocol.TMap _map408 = iprot.readMapBegin(); + _val406 = new HashMap<String, String>(2 * _map408.size); + String _key409; + String _val410; + for (int _i411 = 0; _i411 < _map408.size; ++_i411) { + _key409 = iprot.readString(); + _val410 = iprot.readString(); + _val406.put(_key409, _val410); + } + iprot.readMapEnd(); + } + struct.success.put(_key405, _val406); + } + iprot.readMapEnd(); + } + 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(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + // 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) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getAllInfo_result struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public String toString() { - StringBuilder sb = new StringBuilder("login_args("); - 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("password:"); - if (this.password == null) { - sb.append("null"); - } else { - sb.append(this.password); - } - first = false; - sb.append(")"); - return sb.toString(); - } + 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.MAP, struct.success.size())); + for (Map.Entry<String, Map<String, String>> _iter412 : struct.success.entrySet()) { + oprot.writeString(_iter412.getKey()); + { + oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter412.getValue().size())); + for (Map.Entry<String, String> _iter413 : _iter412.getValue().entrySet()) { + oprot.writeString(_iter413.getKey()); + oprot.writeString(_iter413.getValue()); + } + oprot.writeMapEnd(); + } + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class getAllInfo_resultTupleSchemeFactory implements SchemeFactory { + public getAllInfo_resultTupleScheme getScheme() { + return new getAllInfo_resultTupleScheme(); + } + } - 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.getMessage()); - } - } + private static class getAllInfo_resultTupleScheme extends TupleScheme<getAllInfo_result> { - private static class login_argsStandardSchemeFactory implements SchemeFactory { - public login_argsStandardScheme getScheme() { - return new login_argsStandardScheme(); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getAllInfo_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, Map<String, String>> _iter414 : struct.success.entrySet()) { + oprot.writeString(_iter414.getKey()); + { + oprot.writeI32(_iter414.getValue().size()); + for (Map.Entry<String, String> _iter415 : _iter414.getValue().entrySet()) { + oprot.writeString(_iter415.getKey()); + oprot.writeString(_iter415.getValue()); + } + } + } + } + } + } - private static class login_argsStandardScheme extends StandardScheme<login_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, login_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: // 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: // PASSWORD - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(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, login_args 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.password != null) { - oprot.writeFieldBegin(PASSWORD_FIELD_DESC); - oprot.writeString(struct.password); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getAllInfo_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map416 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32()); + struct.success = new HashMap<String, Map<String, String>>(2 * _map416.size); + String _key417; + Map<String, String> _val418; + for (int _i419 = 0; _i419 < _map416.size; ++_i419) { + _key417 = iprot.readString(); + { + org.apache.thrift.protocol.TMap _map420 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + _val418 = new HashMap<String, String>(2 * _map420.size); + String _key421; + String _val422; + for (int _i423 = 0; _i423 < _map420.size; ++_i423) { + _key421 = iprot.readString(); + _val422 = iprot.readString(); + _val418.put(_key421, _val422); + } + } + struct.success.put(_key417, _val418); + } + } + struct.setSuccessIsSet(true); + } + } + } } - private static class login_argsTupleSchemeFactory implements SchemeFactory { - public login_argsTupleScheme getScheme() { - return new login_argsTupleScheme(); - } - } + public static class getInfoByPlugin_args implements org.apache.thrift.TBase<getInfoByPlugin_args, getInfoByPlugin_args._Fields>, java.io.Serializable, Cloneable, Comparable<getInfoByPlugin_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getInfoByPlugin_args"); - private static class login_argsTupleScheme extends TupleScheme<login_args> { + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, login_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUsername()) { - optionals.set(0); - } - if (struct.isSetPassword()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetUsername()) { - oprot.writeString(struct.username); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new getInfoByPlugin_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getInfoByPlugin_argsTupleSchemeFactory()); } - if (struct.isSetPassword()) { - oprot.writeString(struct.password); + + public String plugin; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(plugin); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, login_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.username = iprot.readString(); - struct.setUsernameIsSet(true); + @Override + public int describeContents() { + return 0; } - if (incoming.get(1)) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); + + public getInfoByPlugin_args(android.os.Parcel in) { + this.plugin = in.readString(); } - } - } - } + public static final android.os.Parcelable.Creator<getInfoByPlugin_args> CREATOR = new android.os.Parcelable.Creator<getInfoByPlugin_args>() { + @Override + public getInfoByPlugin_args[] newArray(int size) { + return new getInfoByPlugin_args[size]; + } - public static class login_result implements org.apache.thrift.TBase<login_result, login_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("login_result"); + @Override + public getInfoByPlugin_args createFromParcel(android.os.Parcel in) { + return new getInfoByPlugin_args(in); + } + }; - 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); + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new login_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new login_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public boolean 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 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 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 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(login_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // PLUGIN + return PLUGIN; + default: + return null; + } + } - public login_result() { - } + /** + * 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; + } - public login_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public login_result(login_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + private final short _thriftId; + private final String _fieldName; - public login_result deepCopy() { - return new login_result(this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + public short getThriftFieldId() { + return _thriftId; + } - public boolean isSuccess() { - return this.success; - } + public String getFieldName() { + return _fieldName; + } + } - public login_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getInfoByPlugin_args.class, metaDataMap); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + public getInfoByPlugin_args() { + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + public getInfoByPlugin_args( + String plugin) { + this(); + this.plugin = plugin; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + /** + * Performs a deep copy on <i>other</i>. + */ + public getInfoByPlugin_args(getInfoByPlugin_args other) { + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } } - break; - } - } + public getInfoByPlugin_args deepCopy() { + return new getInfoByPlugin_args(this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + @Override + public void clear() { + this.plugin = null; + } - } - throw new IllegalStateException(); - } + public String getPlugin() { + return this.plugin; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public getInfoByPlugin_args setPlugin(String plugin) { + this.plugin = plugin; + return this; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof login_result) - return this.equals((login_result)that); - return false; - } + public void unsetPlugin() { + this.plugin = null; + } - public boolean equals(login_result that) { - if (that == null) - return false; + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } - 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; - } + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } - return true; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; - @Override - public int hashCode() { - return 0; - } + } + } - public int compareTo(login_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - login_result typedOther = (login_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** 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(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + switch (field) { + case PLUGIN: + return isSetPlugin(); + } + throw new IllegalStateException(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("login_result("); - boolean first = true; + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getInfoByPlugin_args) + return this.equals((getInfoByPlugin_args) that); + return false; + } - sb.append("success:"); - sb.append(this.success); - first = false; - sb.append(")"); - return sb.toString(); - } + public boolean equals(getInfoByPlugin_args that) { + if (that == null) + return false; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + return true; + } - 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.getMessage()); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static class login_resultStandardSchemeFactory implements SchemeFactory { - public login_resultStandardScheme getScheme() { - return new login_resultStandardScheme(); - } - } + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); - private static class login_resultStandardScheme extends StandardScheme<login_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, login_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; - 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, login_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + return list.hashCode(); + } - } + @Override + public int compareTo(getInfoByPlugin_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - private static class login_resultTupleSchemeFactory implements SchemeFactory { - public login_resultTupleScheme getScheme() { - return new login_resultTupleScheme(); - } - } + int lastComparison = 0; - private static class login_resultTupleScheme extends TupleScheme<login_result> { + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, login_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); + + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, login_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + 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("getInfoByPlugin_args("); + boolean first = true; - public static class getUserData_args implements org.apache.thrift.TBase<getUserData_args, getUserData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserData_args"); + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + sb.append(")"); + return sb.toString(); + } - 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 PASSWORD_FIELD_DESC = new org.apache.thrift.protocol.TField("password", org.apache.thrift.protocol.TType.STRING, (short)2); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getUserData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getUserData_argsTupleSchemeFactory()); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public String username; // required - public String password; // 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 { - USERNAME((short)1, "username"), - PASSWORD((short)2, "password"); - - 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: // USERNAME - return USERNAME; - case 2: // PASSWORD - return PASSWORD; - 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; - } - } + 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); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.USERNAME, new org.apache.thrift.meta_data.FieldMetaData("username", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.PASSWORD, new org.apache.thrift.meta_data.FieldMetaData("password", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserData_args.class, metaDataMap); - } + private static class getInfoByPlugin_argsStandardSchemeFactory implements SchemeFactory { + public getInfoByPlugin_argsStandardScheme getScheme() { + return new getInfoByPlugin_argsStandardScheme(); + } + } - public getUserData_args() { - } + private static class getInfoByPlugin_argsStandardScheme extends StandardScheme<getInfoByPlugin_args> { - public getUserData_args( - String username, - String password) - { - this(); - this.username = username; - this.password = password; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getInfoByPlugin_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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(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(); - /** - * Performs a deep copy on <i>other</i>. - */ - public getUserData_args(getUserData_args other) { - if (other.isSetUsername()) { - this.username = other.username; - } - if (other.isSetPassword()) { - this.password = other.password; - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public getUserData_args deepCopy() { - return new getUserData_args(this); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getInfoByPlugin_args struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public void clear() { - this.username = null; - this.password = null; - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public String getUsername() { - return this.username; - } + } - public getUserData_args setUsername(String username) { - this.username = username; - return this; - } + private static class getInfoByPlugin_argsTupleSchemeFactory implements SchemeFactory { + public getInfoByPlugin_argsTupleScheme getScheme() { + return new getInfoByPlugin_argsTupleScheme(); + } + } - public void unsetUsername() { - this.username = null; - } + private static class getInfoByPlugin_argsTupleScheme extends TupleScheme<getInfoByPlugin_args> { - /** Returns true if field username is set (has been assigned a value) and false otherwise */ - public boolean isSetUsername() { - return this.username != null; - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + } - public void setUsernameIsSet(boolean value) { - if (!value) { - this.username = null; - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + } + } - public String getPassword() { - return this.password; } - public getUserData_args setPassword(String password) { - this.password = password; - return this; - } + public static class getInfoByPlugin_result implements org.apache.thrift.TBase<getInfoByPlugin_result, getInfoByPlugin_result._Fields>, java.io.Serializable, Cloneable, Comparable<getInfoByPlugin_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getInfoByPlugin_result"); - public void unsetPassword() { - this.password = null; - } + 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); - /** Returns true if field password is set (has been assigned a value) and false otherwise */ - public boolean isSetPassword() { - return this.password != null; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void setPasswordIsSet(boolean value) { - if (!value) { - this.password = null; - } - } + static { + schemes.put(StandardScheme.class, new getInfoByPlugin_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getInfoByPlugin_resultTupleSchemeFactory()); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case USERNAME: - if (value == null) { - unsetUsername(); - } else { - setUsername((String)value); + public Map<String, String> success; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeMap(success); } - break; - case PASSWORD: - if (value == null) { - unsetPassword(); - } else { - setPassword((String)value); + @Override + public int describeContents() { + return 0; } - break; - } - } + public getInfoByPlugin_result(android.os.Parcel in) { + this.success = new HashMap<String, String>(); + in.readMap(this.success, getInfoByPlugin_result.class.getClassLoader()); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case USERNAME: - return getUsername(); + public static final android.os.Parcelable.Creator<getInfoByPlugin_result> CREATOR = new android.os.Parcelable.Creator<getInfoByPlugin_result>() { + @Override + public getInfoByPlugin_result[] newArray(int size) { + return new getInfoByPlugin_result[size]; + } - case PASSWORD: - return getPassword(); + @Override + public getInfoByPlugin_result createFromParcel(android.os.Parcel in) { + return new getInfoByPlugin_result(in); + } + }; - } - throw new IllegalStateException(); - } + /** 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"); - /** 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 USERNAME: - return isSetUsername(); - case PASSWORD: - return isSetPassword(); - } - throw new IllegalStateException(); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getUserData_args) - return this.equals((getUserData_args)that); - return false; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public boolean equals(getUserData_args that) { - if (that == null) - 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_password = true && this.isSetPassword(); - boolean that_present_password = true && that.isSetPassword(); - if (this_present_password || that_present_password) { - if (!(this_present_password && that_present_password)) - return false; - if (!this.password.equals(that.password)) - return false; - } - - return true; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - @Override - public int hashCode() { - return 0; - } + /** + * 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; + } - public int compareTo(getUserData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getUserData_args typedOther = (getUserData_args)other; - - lastComparison = Boolean.valueOf(isSetUsername()).compareTo(typedOther.isSetUsername()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetUsername()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.username, typedOther.username); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPassword()).compareTo(typedOther.isSetPassword()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPassword()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.password, typedOther.password); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + private final short _thriftId; + private final String _fieldName; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public String getFieldName() { + return _fieldName; + } + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getUserData_args("); - 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("password:"); - if (this.password == null) { - sb.append("null"); - } else { - sb.append(this.password); - } - first = false; - sb.append(")"); - return sb.toString(); - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING), + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getInfoByPlugin_result.class, metaDataMap); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public getInfoByPlugin_result() { + } - 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.getMessage()); - } - } + public getInfoByPlugin_result( + Map<String, String> success) { + this(); + this.success = success; + } - private static class getUserData_argsStandardSchemeFactory implements SchemeFactory { - public getUserData_argsStandardScheme getScheme() { - return new getUserData_argsStandardScheme(); - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getInfoByPlugin_result(getInfoByPlugin_result other) { + if (other.isSetSuccess()) { + Map<String, String> __this__success = new HashMap<String, String>(other.success); + this.success = __this__success; + } + } - private static class getUserData_argsStandardScheme extends StandardScheme<getUserData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getUserData_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: // 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: // PASSWORD - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(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, getUserData_args 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.password != null) { - oprot.writeFieldBegin(PASSWORD_FIELD_DESC); - oprot.writeString(struct.password); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public getInfoByPlugin_result deepCopy() { + return new getInfoByPlugin_result(this); + } - } + @Override + public void clear() { + this.success = null; + } - private static class getUserData_argsTupleSchemeFactory implements SchemeFactory { - public getUserData_argsTupleScheme getScheme() { - return new getUserData_argsTupleScheme(); - } - } + public int getSuccessSize() { + return (this.success == null) ? 0 : this.success.size(); + } - private static class getUserData_argsTupleScheme extends TupleScheme<getUserData_args> { + public void putToSuccess(String key, String val) { + if (this.success == null) { + this.success = new HashMap<String, String>(); + } + this.success.put(key, val); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getUserData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetUsername()) { - optionals.set(0); + public Map<String, String> getSuccess() { + return this.success; } - if (struct.isSetPassword()) { - optionals.set(1); + + public getInfoByPlugin_result setSuccess(Map<String, String> success) { + this.success = success; + return this; } - oprot.writeBitSet(optionals, 2); - if (struct.isSetUsername()) { - oprot.writeString(struct.username); + + public void unsetSuccess() { + this.success = null; } - if (struct.isSetPassword()) { - oprot.writeString(struct.password); + + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getUserData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.username = iprot.readString(); - struct.setUsernameIsSet(true); + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } } - if (incoming.get(1)) { - struct.password = iprot.readString(); - struct.setPasswordIsSet(true); + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Map<String, String>) value); + } + break; + + } } - } - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public static class getUserData_result implements org.apache.thrift.TBase<getUserData_result, getUserData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getUserData_result"); + } + throw new IllegalStateException(); + } - 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); + /** 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getUserData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getUserData_resultTupleSchemeFactory()); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public UserData 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 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 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 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; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getInfoByPlugin_result) + return this.equals((getInfoByPlugin_result) that); + return false; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserData.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getUserData_result.class, metaDataMap); - } + public boolean equals(getInfoByPlugin_result that) { + if (that == null) + return false; - public getUserData_result() { - } + 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; + } - public getUserData_result( - UserData success) - { - this(); - this.success = success; - } + return true; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getUserData_result(getUserData_result other) { - if (other.isSetSuccess()) { - this.success = new UserData(other.success); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public getUserData_result deepCopy() { - return new getUserData_result(this); - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - @Override - public void clear() { - this.success = null; - } + return list.hashCode(); + } - public UserData getSuccess() { - return this.success; - } + @Override + public int compareTo(getInfoByPlugin_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public getUserData_result setSuccess(UserData success) { - this.success = success; - return this; - } + int lastComparison = 0; - public void unsetSuccess() { - this.success = null; - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((UserData)value); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); } - break; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getInfoByPlugin_result("); + boolean first = true; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + sb.append("success:"); + if (this.success == null) { + sb.append("null"); + } else { + sb.append(this.success); + } + first = false; + sb.append(")"); + return sb.toString(); + } - } - throw new IllegalStateException(); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getUserData_result) - return this.equals((getUserData_result)that); - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public boolean equals(getUserData_result that) { - if (that == null) - return false; + private static class getInfoByPlugin_resultStandardSchemeFactory implements SchemeFactory { + public getInfoByPlugin_resultStandardScheme getScheme() { + return new getInfoByPlugin_resultStandardScheme(); + } + } - 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; - } + private static class getInfoByPlugin_resultStandardScheme extends StandardScheme<getInfoByPlugin_result> { - return true; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getInfoByPlugin_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 _map424 = iprot.readMapBegin(); + struct.success = new HashMap<String, String>(2 * _map424.size); + String _key425; + String _val426; + for (int _i427 = 0; _i427 < _map424.size; ++_i427) { + _key425 = iprot.readString(); + _val426 = iprot.readString(); + struct.success.put(_key425, _val426); + } + iprot.readMapEnd(); + } + 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(); - @Override - public int hashCode() { - return 0; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public int compareTo(getUserData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getUserData_result typedOther = (getUserData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getInfoByPlugin_result struct) throws org.apache.thrift.TException { + struct.validate(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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.STRING, struct.success.size())); + for (Map.Entry<String, String> _iter428 : struct.success.entrySet()) { + oprot.writeString(_iter428.getKey()); + oprot.writeString(_iter428.getValue()); + } + oprot.writeMapEnd(); + } + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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("getUserData_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(); - } + private static class getInfoByPlugin_resultTupleSchemeFactory implements SchemeFactory { + public getInfoByPlugin_resultTupleScheme getScheme() { + return new getInfoByPlugin_resultTupleScheme(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class getInfoByPlugin_resultTupleScheme extends TupleScheme<getInfoByPlugin_result> { - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + { + oprot.writeI32(struct.success.size()); + for (Map.Entry<String, String> _iter429 : struct.success.entrySet()) { + oprot.writeString(_iter429.getKey()); + oprot.writeString(_iter429.getValue()); + } + } + } + } - 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.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + { + org.apache.thrift.protocol.TMap _map430 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.success = new HashMap<String, String>(2 * _map430.size); + String _key431; + String _val432; + for (int _i433 = 0; _i433 < _map430.size; ++_i433) { + _key431 = iprot.readString(); + _val432 = iprot.readString(); + struct.success.put(_key431, _val432); + } + } + struct.setSuccessIsSet(true); + } + } + } - private static class getUserData_resultStandardSchemeFactory implements SchemeFactory { - public getUserData_resultStandardScheme getScheme() { - return new getUserData_resultStandardScheme(); - } } - private static class getUserData_resultStandardScheme extends StandardScheme<getUserData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getUserData_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 UserData(); - struct.success.read(iprot); - 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, getUserData_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(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public static class isCaptchaWaiting_args implements org.apache.thrift.TBase<isCaptchaWaiting_args, isCaptchaWaiting_args._Fields>, java.io.Serializable, Cloneable, Comparable<isCaptchaWaiting_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isCaptchaWaiting_args"); - } - private static class getUserData_resultTupleSchemeFactory implements SchemeFactory { - public getUserData_resultTupleScheme getScheme() { - return new getUserData_resultTupleScheme(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new isCaptchaWaiting_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isCaptchaWaiting_argsTupleSchemeFactory()); + } - private static class getUserData_resultTupleScheme extends TupleScheme<getUserData_result> { - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getUserData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - struct.success.write(oprot); + + @Override + public int describeContents() { + return 0; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getUserData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = new UserData(); - struct.success.read(iprot); - struct.setSuccessIsSet(true); + public isCaptchaWaiting_args(android.os.Parcel in) { } - } - } - } + public static final android.os.Parcelable.Creator<isCaptchaWaiting_args> CREATOR = new android.os.Parcelable.Creator<isCaptchaWaiting_args>() { + @Override + public isCaptchaWaiting_args[] newArray(int size) { + return new isCaptchaWaiting_args[size]; + } - public static class getAllUserData_args implements org.apache.thrift.TBase<getAllUserData_args, getAllUserData_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllUserData_args"); + @Override + public isCaptchaWaiting_args createFromParcel(android.os.Parcel in) { + return new isCaptchaWaiting_args(in); + } + }; + /** 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAllUserData_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAllUserData_argsTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllUserData_args.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public getAllUserData_args() { - } + /** + * 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; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAllUserData_args(getAllUserData_args other) { - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public getAllUserData_args deepCopy() { - return new getAllUserData_args(this); - } + private final short _thriftId; + private final String _fieldName; - @Override - public void clear() { - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + public short getThriftFieldId() { + return _thriftId; + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + public String getFieldName() { + return _fieldName; + } + } - /** 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(); - } + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - switch (field) { - } - throw new IllegalStateException(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isCaptchaWaiting_args.class, metaDataMap); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAllUserData_args) - return this.equals((getAllUserData_args)that); - return false; - } + public isCaptchaWaiting_args() { + } - public boolean equals(getAllUserData_args that) { - if (that == null) - return false; + /** + * Performs a deep copy on <i>other</i>. + */ + public isCaptchaWaiting_args(isCaptchaWaiting_args other) { + } - return true; - } + public isCaptchaWaiting_args deepCopy() { + return new isCaptchaWaiting_args(this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public void clear() { + } - public int compareTo(getAllUserData_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - int lastComparison = 0; - getAllUserData_args typedOther = (getAllUserData_args)other; + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - return 0; - } + /** 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(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + switch (field) { + } + throw new IllegalStateException(); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isCaptchaWaiting_args) + return this.equals((isCaptchaWaiting_args) that); + return false; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public boolean equals(isCaptchaWaiting_args that) { + if (that == null) + return false; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getAllUserData_args("); - boolean first = true; + return true; + } - sb.append(")"); - return sb.toString(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + 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.getMessage()); - } - } + @Override + public int compareTo(isCaptchaWaiting_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - 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.getMessage()); - } - } + int lastComparison = 0; - private static class getAllUserData_argsStandardSchemeFactory implements SchemeFactory { - public getAllUserData_argsStandardScheme getScheme() { - return new getAllUserData_argsStandardScheme(); - } - } + return 0; + } - private static class getAllUserData_argsStandardScheme extends StandardScheme<getAllUserData_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAllUserData_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, getAllUserData_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + 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); + } - private static class getAllUserData_argsTupleSchemeFactory implements SchemeFactory { - public getAllUserData_argsTupleScheme getScheme() { - return new getAllUserData_argsTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - private static class getAllUserData_argsTupleScheme extends TupleScheme<getAllUserData_args> { + @Override + public String toString() { + StringBuilder sb = new StringBuilder("isCaptchaWaiting_args("); + boolean first = true; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAllUserData_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + sb.append(")"); + return sb.toString(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAllUserData_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + 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); + } + } - public static class getAllUserData_result implements org.apache.thrift.TBase<getAllUserData_result, getAllUserData_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllUserData_result"); + 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 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 class isCaptchaWaiting_argsStandardSchemeFactory implements SchemeFactory { + public isCaptchaWaiting_argsStandardScheme getScheme() { + return new isCaptchaWaiting_argsStandardScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAllUserData_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAllUserData_resultTupleSchemeFactory()); - } + private static class isCaptchaWaiting_argsStandardScheme extends StandardScheme<isCaptchaWaiting_args> { - public Map<String,UserData> 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 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 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 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; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, isCaptchaWaiting_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(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, UserData.class)))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllUserData_result.class, metaDataMap); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - public getAllUserData_result() { - } + public void write(org.apache.thrift.protocol.TProtocol oprot, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { + struct.validate(); - public getAllUserData_result( - Map<String,UserData> success) - { - this(); - this.success = success; - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAllUserData_result(getAllUserData_result other) { - if (other.isSetSuccess()) { - Map<String,UserData> __this__success = new HashMap<String,UserData>(); - for (Map.Entry<String, UserData> other_element : other.success.entrySet()) { + } - String other_element_key = other_element.getKey(); - UserData other_element_value = other_element.getValue(); + private static class isCaptchaWaiting_argsTupleSchemeFactory implements SchemeFactory { + public isCaptchaWaiting_argsTupleScheme getScheme() { + return new isCaptchaWaiting_argsTupleScheme(); + } + } - String __this__success_copy_key = other_element_key; + private static class isCaptchaWaiting_argsTupleScheme extends TupleScheme<isCaptchaWaiting_args> { - UserData __this__success_copy_value = new UserData(other_element_value); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } - __this__success.put(__this__success_copy_key, __this__success_copy_value); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } } - this.success = __this__success; - } - } - - public getAllUserData_result deepCopy() { - return new getAllUserData_result(this); - } - - @Override - public void clear() { - this.success = null; - } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); } - public void putToSuccess(String key, UserData val) { - if (this.success == null) { - this.success = new HashMap<String,UserData>(); - } - this.success.put(key, val); - } + public static class isCaptchaWaiting_result implements org.apache.thrift.TBase<isCaptchaWaiting_result, isCaptchaWaiting_result._Fields>, java.io.Serializable, Cloneable, Comparable<isCaptchaWaiting_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("isCaptchaWaiting_result"); - public Map<String,UserData> getSuccess() { - return this.success; - } + 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); - public getAllUserData_result setSuccess(Map<String,UserData> success) { - this.success = success; - return this; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public void unsetSuccess() { - this.success = null; - } + static { + schemes.put(StandardScheme.class, new isCaptchaWaiting_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new isCaptchaWaiting_resultTupleSchemeFactory()); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public boolean success; // required - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,UserData>)value); + out.writeInt(success ? 1 : 0); } - break; - - } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + @Override + public int describeContents() { + return 0; + } - } - throw new IllegalStateException(); - } + public isCaptchaWaiting_result(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + this.success = (in.readInt() == 1); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAllUserData_result) - return this.equals((getAllUserData_result)that); - return false; - } + public static final android.os.Parcelable.Creator<isCaptchaWaiting_result> CREATOR = new android.os.Parcelable.Creator<isCaptchaWaiting_result>() { + @Override + public isCaptchaWaiting_result[] newArray(int size) { + return new isCaptchaWaiting_result[size]; + } - public boolean equals(getAllUserData_result that) { - if (that == null) - return false; + @Override + public isCaptchaWaiting_result createFromParcel(android.os.Parcel in) { + return new isCaptchaWaiting_result(in); + } + }; - 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; - } + /** 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"); - return true; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - @Override - public int hashCode() { - return 0; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public int compareTo(getAllUserData_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getAllUserData_result typedOther = (getAllUserData_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** + * 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; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - 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("getAllUserData_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(); - } + private final short _thriftId; + private final String _fieldName; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public short getThriftFieldId() { + return _thriftId; + } - 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.getMessage()); - } - } + public String getFieldName() { + return _fieldName; + } + } - private static class getAllUserData_resultStandardSchemeFactory implements SchemeFactory { - public getAllUserData_resultStandardScheme getScheme() { - return new getAllUserData_resultStandardScheme(); - } - } + // isset id assignments + private static final int __SUCCESS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - private static class getAllUserData_resultStandardScheme extends StandardScheme<getAllUserData_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAllUserData_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 _map350 = iprot.readMapBegin(); - struct.success = new HashMap<String,UserData>(2*_map350.size); - for (int _i351 = 0; _i351 < _map350.size; ++_i351) - { - String _key352; // required - UserData _val353; // required - _key352 = iprot.readString(); - _val353 = new UserData(); - _val353.read(iprot); - struct.success.put(_key352, _val353); - } - iprot.readMapEnd(); - } - 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, getAllUserData_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 (Map.Entry<String, UserData> _iter354 : struct.success.entrySet()) - { - oprot.writeString(_iter354.getKey()); - _iter354.getValue().write(oprot); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(isCaptchaWaiting_result.class, metaDataMap); + } - } + public isCaptchaWaiting_result() { + } - private static class getAllUserData_resultTupleSchemeFactory implements SchemeFactory { - public getAllUserData_resultTupleScheme getScheme() { - return new getAllUserData_resultTupleScheme(); - } - } + public isCaptchaWaiting_result( + boolean success) { + this(); + this.success = success; + setSuccessIsSet(true); + } - private static class getAllUserData_resultTupleScheme extends TupleScheme<getAllUserData_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAllUserData_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, UserData> _iter355 : struct.success.entrySet()) - { - oprot.writeString(_iter355.getKey()); - _iter355.getValue().write(oprot); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAllUserData_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map356 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRUCT, iprot.readI32()); - struct.success = new HashMap<String,UserData>(2*_map356.size); - for (int _i357 = 0; _i357 < _map356.size; ++_i357) - { - String _key358; // required - UserData _val359; // required - _key358 = iprot.readString(); - _val359 = new UserData(); - _val359.read(iprot); - struct.success.put(_key358, _val359); - } - } - struct.setSuccessIsSet(true); - } - } - } + /** + * Performs a deep copy on <i>other</i>. + */ + public isCaptchaWaiting_result(isCaptchaWaiting_result other) { + __isset_bitfield = other.__isset_bitfield; + this.success = other.success; + } - } + public isCaptchaWaiting_result deepCopy() { + return new isCaptchaWaiting_result(this); + } - public static class getServices_args implements org.apache.thrift.TBase<getServices_args, getServices_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServices_args"); + @Override + public void clear() { + setSuccessIsSet(false); + this.success = false; + } + public boolean isSuccess() { + return this.success; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getServices_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getServices_argsTupleSchemeFactory()); - } + public isCaptchaWaiting_result setSuccess(boolean success) { + this.success = success; + setSuccessIsSet(true); + return this; + } + public void unsetSuccess() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { -; - - 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getServices_args.class, metaDataMap); - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return EncodingUtils.testBit(__isset_bitfield, __SUCCESS_ISSET_ID); + } - public getServices_args() { - } + public void setSuccessIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SUCCESS_ISSET_ID, value); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getServices_args(getServices_args other) { - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((Boolean) value); + } + break; - public getServices_args deepCopy() { - return new getServices_args(this); - } + } + } - @Override - public void clear() { - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return isSuccess(); - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + } + throw new IllegalStateException(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - 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(); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof isCaptchaWaiting_result) + return this.equals((isCaptchaWaiting_result) that); + return false; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getServices_args) - return this.equals((getServices_args)that); - return false; - } + public boolean equals(isCaptchaWaiting_result that) { + if (that == null) + return false; - public boolean equals(getServices_args that) { - if (that == null) - return false; + 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; + } - return true; - } + return true; + } - @Override - public int hashCode() { - return 0; - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public int compareTo(getServices_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + boolean present_success = true; + list.add(present_success); + if (present_success) + list.add(success); - int lastComparison = 0; - getServices_args typedOther = (getServices_args)other; + return list.hashCode(); + } - return 0; - } + @Override + public int compareTo(isCaptchaWaiting_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + int lastComparison = 0; - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("getServices_args("); - boolean first = true; + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - sb.append(")"); - return sb.toString(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("isCaptchaWaiting_result("); + boolean first = true; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + sb.append("success:"); + sb.append(this.success); + first = false; + sb.append(")"); + return sb.toString(); + } - 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.getMessage()); - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - private static class getServices_argsStandardSchemeFactory implements SchemeFactory { - public getServices_argsStandardScheme getScheme() { - return new getServices_argsStandardScheme(); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private static class getServices_argsStandardScheme extends StandardScheme<getServices_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getServices_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, getServices_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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 isCaptchaWaiting_resultStandardSchemeFactory implements SchemeFactory { + public isCaptchaWaiting_resultStandardScheme getScheme() { + return new isCaptchaWaiting_resultStandardScheme(); + } + } - private static class getServices_argsTupleSchemeFactory implements SchemeFactory { - public getServices_argsTupleScheme getScheme() { - return new getServices_argsTupleScheme(); - } - } + private static class isCaptchaWaiting_resultStandardScheme extends StandardScheme<isCaptchaWaiting_result> { - private static class getServices_argsTupleScheme extends TupleScheme<getServices_args> { + public void read(org.apache.thrift.protocol.TProtocol iprot, isCaptchaWaiting_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; + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getServices_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getServices_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, isCaptchaWaiting_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(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public static class getServices_result implements org.apache.thrift.TBase<getServices_result, getServices_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getServices_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 class isCaptchaWaiting_resultTupleSchemeFactory implements SchemeFactory { + public isCaptchaWaiting_resultTupleScheme getScheme() { + return new isCaptchaWaiting_resultTupleScheme(); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getServices_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getServices_resultTupleSchemeFactory()); - } + private static class isCaptchaWaiting_resultTupleScheme extends TupleScheme<isCaptchaWaiting_result> { - public Map<String,Map<String,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 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 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 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; - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeBool(struct.success); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"), - 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(getServices_result.class, metaDataMap); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, isCaptchaWaiting_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readBool(); + struct.setSuccessIsSet(true); + } + } + } - public getServices_result() { } - public getServices_result( - Map<String,Map<String,String>> success) - { - this(); - this.success = success; - } + public static class getCaptchaTask_args implements org.apache.thrift.TBase<getCaptchaTask_args, getCaptchaTask_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCaptchaTask_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTask_args"); - /** - * Performs a deep copy on <i>other</i>. - */ - public getServices_result(getServices_result other) { - if (other.isSetSuccess()) { - Map<String,Map<String,String>> __this__success = new HashMap<String,Map<String,String>>(); - for (Map.Entry<String, Map<String,String>> other_element : other.success.entrySet()) { + private static final org.apache.thrift.protocol.TField EXCLUSIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("exclusive", org.apache.thrift.protocol.TType.BOOL, (short) 1); - String other_element_key = other_element.getKey(); - Map<String,String> other_element_value = other_element.getValue(); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - String __this__success_copy_key = other_element_key; + static { + schemes.put(StandardScheme.class, new getCaptchaTask_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCaptchaTask_argsTupleSchemeFactory()); + } - Map<String,String> __this__success_copy_value = new HashMap<String,String>(); - for (Map.Entry<String, String> other_element_value_element : other_element_value.entrySet()) { + public boolean exclusive; // required - String other_element_value_element_key = other_element_value_element.getKey(); - String other_element_value_element_value = other_element_value_element.getValue(); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - String __this__success_copy_value_copy_key = other_element_value_element_key; + out.writeInt(exclusive ? 1 : 0); + } - String __this__success_copy_value_copy_value = other_element_value_element_value; + @Override + public int describeContents() { + return 0; + } - __this__success_copy_value.put(__this__success_copy_value_copy_key, __this__success_copy_value_copy_value); - } + public getCaptchaTask_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - __this__success.put(__this__success_copy_key, __this__success_copy_value); + this.exclusive = (in.readInt() == 1); } - this.success = __this__success; - } - } - public getServices_result deepCopy() { - return new getServices_result(this); - } + public static final android.os.Parcelable.Creator<getCaptchaTask_args> CREATOR = new android.os.Parcelable.Creator<getCaptchaTask_args>() { + @Override + public getCaptchaTask_args[] newArray(int size) { + return new getCaptchaTask_args[size]; + } - @Override - public void clear() { - this.success = null; - } + @Override + public getCaptchaTask_args createFromParcel(android.os.Parcel in) { + return new getCaptchaTask_args(in); + } + }; - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + EXCLUSIVE((short) 1, "exclusive"); - public void putToSuccess(String key, Map<String,String> val) { - if (this.success == null) { - this.success = new HashMap<String,Map<String,String>>(); - } - this.success.put(key, val); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Map<String,Map<String,String>> getSuccess() { - return this.success; - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public getServices_result setSuccess(Map<String,Map<String,String>> success) { - this.success = success; - return this; - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // EXCLUSIVE + return EXCLUSIVE; + default: + return null; + } + } - public void unsetSuccess() { - this.success = 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; + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,Map<String,String>>)value); + public String getFieldName() { + return _fieldName; + } } - break; - } - } + // isset id assignments + private static final int __EXCLUSIVE_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.EXCLUSIVE, new org.apache.thrift.meta_data.FieldMetaData("exclusive", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTask_args.class, metaDataMap); + } - } - throw new IllegalStateException(); - } + public getCaptchaTask_args() { + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public getCaptchaTask_args( + boolean exclusive) { + this(); + this.exclusive = exclusive; + setExclusiveIsSet(true); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getServices_result) - return this.equals((getServices_result)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getCaptchaTask_args(getCaptchaTask_args other) { + __isset_bitfield = other.__isset_bitfield; + this.exclusive = other.exclusive; + } - public boolean equals(getServices_result that) { - if (that == null) - return false; + public getCaptchaTask_args deepCopy() { + return new getCaptchaTask_args(this); + } - 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; - } + @Override + public void clear() { + setExclusiveIsSet(false); + this.exclusive = false; + } - return true; - } + public boolean isExclusive() { + return this.exclusive; + } - @Override - public int hashCode() { - return 0; - } + public getCaptchaTask_args setExclusive(boolean exclusive) { + this.exclusive = exclusive; + setExclusiveIsSet(true); + return this; + } - public int compareTo(getServices_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getServices_result typedOther = (getServices_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void unsetExclusive() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __EXCLUSIVE_ISSET_ID); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** Returns true if field exclusive is set (has been assigned a value) and false otherwise */ + public boolean isSetExclusive() { + return EncodingUtils.testBit(__isset_bitfield, __EXCLUSIVE_ISSET_ID); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void setExclusiveIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __EXCLUSIVE_ISSET_ID, value); + } - 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("getServices_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 setFieldValue(_Fields field, Object value) { + switch (field) { + case EXCLUSIVE: + if (value == null) { + unsetExclusive(); + } else { + setExclusive((Boolean) value); + } + break; - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case EXCLUSIVE: + return isExclusive(); - 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.getMessage()); - } - } + } + throw new IllegalStateException(); + } - private static class getServices_resultStandardSchemeFactory implements SchemeFactory { - public getServices_resultStandardScheme getScheme() { - return new getServices_resultStandardScheme(); - } - } + /** 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(); + } - private static class getServices_resultStandardScheme extends StandardScheme<getServices_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getServices_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 _map360 = iprot.readMapBegin(); - struct.success = new HashMap<String,Map<String,String>>(2*_map360.size); - for (int _i361 = 0; _i361 < _map360.size; ++_i361) - { - String _key362; // required - Map<String,String> _val363; // required - _key362 = iprot.readString(); - { - org.apache.thrift.protocol.TMap _map364 = iprot.readMapBegin(); - _val363 = new HashMap<String,String>(2*_map364.size); - for (int _i365 = 0; _i365 < _map364.size; ++_i365) - { - String _key366; // required - String _val367; // required - _key366 = iprot.readString(); - _val367 = iprot.readString(); - _val363.put(_key366, _val367); - } - iprot.readMapEnd(); - } - struct.success.put(_key362, _val363); - } - iprot.readMapEnd(); - } - 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, getServices_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.MAP, struct.success.size())); - for (Map.Entry<String, Map<String,String>> _iter368 : struct.success.entrySet()) - { - oprot.writeString(_iter368.getKey()); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter368.getValue().size())); - for (Map.Entry<String, String> _iter369 : _iter368.getValue().entrySet()) - { - oprot.writeString(_iter369.getKey()); - oprot.writeString(_iter369.getValue()); - } - oprot.writeMapEnd(); - } - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + switch (field) { + case EXCLUSIVE: + return isSetExclusive(); + } + throw new IllegalStateException(); + } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCaptchaTask_args) + return this.equals((getCaptchaTask_args) that); + return false; + } - private static class getServices_resultTupleSchemeFactory implements SchemeFactory { - public getServices_resultTupleScheme getScheme() { - return new getServices_resultTupleScheme(); - } - } + public boolean equals(getCaptchaTask_args that) { + if (that == null) + return false; - private static class getServices_resultTupleScheme extends TupleScheme<getServices_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getServices_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, Map<String,String>> _iter370 : struct.success.entrySet()) - { - oprot.writeString(_iter370.getKey()); - { - oprot.writeI32(_iter370.getValue().size()); - for (Map.Entry<String, String> _iter371 : _iter370.getValue().entrySet()) - { - oprot.writeString(_iter371.getKey()); - oprot.writeString(_iter371.getValue()); - } - } - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getServices_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map372 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32()); - struct.success = new HashMap<String,Map<String,String>>(2*_map372.size); - for (int _i373 = 0; _i373 < _map372.size; ++_i373) - { - String _key374; // required - Map<String,String> _val375; // required - _key374 = iprot.readString(); - { - org.apache.thrift.protocol.TMap _map376 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val375 = new HashMap<String,String>(2*_map376.size); - for (int _i377 = 0; _i377 < _map376.size; ++_i377) - { - String _key378; // required - String _val379; // required - _key378 = iprot.readString(); - _val379 = iprot.readString(); - _val375.put(_key378, _val379); - } - } - struct.success.put(_key374, _val375); - } - } - struct.setSuccessIsSet(true); - } - } - } + boolean this_present_exclusive = true; + boolean that_present_exclusive = true; + if (this_present_exclusive || that_present_exclusive) { + if (!(this_present_exclusive && that_present_exclusive)) + return false; + if (this.exclusive != that.exclusive) + return false; + } - } + return true; + } - public static class hasService_args implements org.apache.thrift.TBase<hasService_args, hasService_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasService_args"); + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short)2); + boolean present_exclusive = true; + list.add(present_exclusive); + if (present_exclusive) + list.add(exclusive); - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new hasService_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new hasService_argsTupleSchemeFactory()); - } + return list.hashCode(); + } - public String plugin; // required - public String func; // 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 { - PLUGIN((short)1, "plugin"), - FUNC((short)2, "func"); - - 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: // PLUGIN - return PLUGIN; - case 2: // FUNC - return FUNC; - 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; - } - } + @Override + public int compareTo(getCaptchaTask_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasService_args.class, metaDataMap); - } + int lastComparison = 0; - public hasService_args() { - } + lastComparison = Boolean.valueOf(isSetExclusive()).compareTo(other.isSetExclusive()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetExclusive()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.exclusive, other.exclusive); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public hasService_args( - String plugin, - String func) - { - this(); - this.plugin = plugin; - this.func = func; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public hasService_args(hasService_args other) { - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetFunc()) { - this.func = other.func; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public hasService_args deepCopy() { - return new hasService_args(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 void clear() { - this.plugin = null; - this.func = null; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCaptchaTask_args("); + boolean first = true; - public String getPlugin() { - return this.plugin; - } + sb.append("exclusive:"); + sb.append(this.exclusive); + first = false; + sb.append(")"); + return sb.toString(); + } - public hasService_args setPlugin(String plugin) { - this.plugin = plugin; - return this; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void unsetPlugin() { - this.plugin = null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } + private static class getCaptchaTask_argsStandardSchemeFactory implements SchemeFactory { + public getCaptchaTask_argsStandardScheme getScheme() { + return new getCaptchaTask_argsStandardScheme(); + } + } - public String getFunc() { - return this.func; - } + private static class getCaptchaTask_argsStandardScheme extends StandardScheme<getCaptchaTask_args> { - public hasService_args setFunc(String func) { - this.func = func; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTask_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: // EXCLUSIVE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.exclusive = iprot.readBool(); + struct.setExclusiveIsSet(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(); - public void unsetFunc() { - this.func = null; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field func is set (has been assigned a value) and false otherwise */ - public boolean isSetFunc() { - return this.func != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCaptchaTask_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void setFuncIsSet(boolean value) { - if (!value) { - this.func = null; - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(EXCLUSIVE_FIELD_DESC); + oprot.writeBool(struct.exclusive); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); } - break; - case FUNC: - if (value == null) { - unsetFunc(); - } else { - setFunc((String)value); + private static class getCaptchaTask_argsTupleSchemeFactory implements SchemeFactory { + public getCaptchaTask_argsTupleScheme getScheme() { + return new getCaptchaTask_argsTupleScheme(); + } } - break; - } - } + private static class getCaptchaTask_argsTupleScheme extends TupleScheme<getCaptchaTask_args> { - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetExclusive()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetExclusive()) { + oprot.writeBool(struct.exclusive); + } + } - case FUNC: - return getFunc(); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.exclusive = iprot.readBool(); + struct.setExclusiveIsSet(true); + } + } + } - } - 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 PLUGIN: - return isSetPlugin(); - case FUNC: - return isSetFunc(); - } - throw new IllegalStateException(); - } + public static class getCaptchaTask_result implements org.apache.thrift.TBase<getCaptchaTask_result, getCaptchaTask_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCaptchaTask_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTask_result"); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof hasService_args) - return this.equals((hasService_args)that); - return false; - } + 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); - public boolean equals(hasService_args that) { - if (that == null) - return false; - - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; - } - - boolean this_present_func = true && this.isSetFunc(); - boolean that_present_func = true && that.isSetFunc(); - if (this_present_func || that_present_func) { - if (!(this_present_func && that_present_func)) - return false; - if (!this.func.equals(that.func)) - return false; - } - - return true; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - @Override - public int hashCode() { - return 0; - } + static { + schemes.put(StandardScheme.class, new getCaptchaTask_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCaptchaTask_resultTupleSchemeFactory()); + } - public int compareTo(hasService_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - hasService_args typedOther = (hasService_args)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFunc()).compareTo(typedOther.isSetFunc()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFunc()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, typedOther.func); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public CaptchaTask success; // required - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeParcelable(success, flags); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public int describeContents() { + return 0; + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public getCaptchaTask_result(android.os.Parcel in) { + this.success = in.readParcelable(getCaptchaTask_result.class.getClassLoader()); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("hasService_args("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("func:"); - if (this.func == null) { - sb.append("null"); - } else { - sb.append(this.func); - } - first = false; - sb.append(")"); - return sb.toString(); - } + public static final android.os.Parcelable.Creator<getCaptchaTask_result> CREATOR = new android.os.Parcelable.Creator<getCaptchaTask_result>() { + @Override + public getCaptchaTask_result[] newArray(int size) { + return new getCaptchaTask_result[size]; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + @Override + public getCaptchaTask_result createFromParcel(android.os.Parcel in) { + return new getCaptchaTask_result(in); + } + }; - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + /** 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 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.getMessage()); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static class hasService_argsStandardSchemeFactory implements SchemeFactory { - public hasService_argsStandardScheme getScheme() { - return new hasService_argsStandardScheme(); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - private static class hasService_argsStandardScheme extends StandardScheme<hasService_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, hasService_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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // FUNC - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.func = iprot.readString(); - struct.setFuncIsSet(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, hasService_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.func != null) { - oprot.writeFieldBegin(FUNC_FIELD_DESC); - oprot.writeString(struct.func); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + 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; + } - private static class hasService_argsTupleSchemeFactory implements SchemeFactory { - public hasService_argsTupleScheme getScheme() { - return new hasService_argsTupleScheme(); - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - private static class hasService_argsTupleScheme extends TupleScheme<hasService_args> { + private final short _thriftId; + private final String _fieldName; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, hasService_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); - } - if (struct.isSetFunc()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetFunc()) { - oprot.writeString(struct.func); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, hasService_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } } - if (incoming.get(1)) { - struct.func = iprot.readString(); - struct.setFuncIsSet(true); + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, CaptchaTask.class))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTask_result.class, metaDataMap); } - } - } - } + public getCaptchaTask_result() { + } - public static class hasService_result implements org.apache.thrift.TBase<hasService_result, hasService_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("hasService_result"); + public getCaptchaTask_result( + CaptchaTask success) { + this(); + this.success = success; + } - 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); + /** + * Performs a deep copy on <i>other</i>. + */ + public getCaptchaTask_result(getCaptchaTask_result other) { + if (other.isSetSuccess()) { + this.success = new CaptchaTask(other.success); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new hasService_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new hasService_resultTupleSchemeFactory()); - } + public getCaptchaTask_result deepCopy() { + return new getCaptchaTask_result(this); + } - public boolean 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 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 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 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; - } - } + @Override + public void clear() { + this.success = null; + } - // isset id assignments - private static final int __SUCCESS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(hasService_result.class, metaDataMap); - } + public CaptchaTask getSuccess() { + return this.success; + } - public hasService_result() { - } + public getCaptchaTask_result setSuccess(CaptchaTask success) { + this.success = success; + return this; + } - public hasService_result( - boolean success) - { - this(); - this.success = success; - setSuccessIsSet(true); - } + public void unsetSuccess() { + this.success = null; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public hasService_result(hasService_result other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.success = other.success; - } + /** Returns true if field success is set (has been assigned a value) and false otherwise */ + public boolean isSetSuccess() { + return this.success != null; + } - public hasService_result deepCopy() { - return new hasService_result(this); - } + public void setSuccessIsSet(boolean value) { + if (!value) { + this.success = null; + } + } - @Override - public void clear() { - setSuccessIsSet(false); - this.success = false; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((CaptchaTask) value); + } + break; - public boolean isSuccess() { - return this.success; - } + } + } - public hasService_result setSuccess(boolean success) { - this.success = success; - setSuccessIsSet(true); - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public void unsetSuccess() { - __isset_bit_vector.clear(__SUCCESS_ISSET_ID); - } + } + throw new IllegalStateException(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return __isset_bit_vector.get(__SUCCESS_ISSET_ID); - } + /** 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(); + } - public void setSuccessIsSet(boolean value) { - __isset_bit_vector.set(__SUCCESS_ISSET_ID, value); - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Boolean)value); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCaptchaTask_result) + return this.equals((getCaptchaTask_result) that); + return false; } - break; - } - } + public boolean equals(getCaptchaTask_result that) { + if (that == null) + return false; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return Boolean.valueOf(isSuccess()); + 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; + } - } - throw new IllegalStateException(); - } + return true; + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof hasService_result) - return this.equals((hasService_result)that); - return false; - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - public boolean equals(hasService_result that) { - if (that == null) - return false; + return list.hashCode(); + } - 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; - } + @Override + public int compareTo(getCaptchaTask_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - return true; - } + int lastComparison = 0; - @Override - public int hashCode() { - return 0; - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public int compareTo(hasService_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - hasService_result typedOther = (hasService_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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 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); + } - 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("getCaptchaTask_result("); + boolean first = true; - @Override - public String toString() { - StringBuilder sb = new StringBuilder("hasService_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(); + } - sb.append("success:"); - 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 + if (success != null) { + success.validate(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + 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 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.getMessage()); - } - } + private static class getCaptchaTask_resultStandardSchemeFactory implements SchemeFactory { + public getCaptchaTask_resultStandardScheme getScheme() { + return new getCaptchaTask_resultStandardScheme(); + } + } - private static class hasService_resultStandardSchemeFactory implements SchemeFactory { - public hasService_resultStandardScheme getScheme() { - return new hasService_resultStandardScheme(); - } - } + private static class getCaptchaTask_resultStandardScheme extends StandardScheme<getCaptchaTask_result> { - private static class hasService_resultStandardScheme extends StandardScheme<hasService_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, hasService_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; - 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, hasService_result struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(SUCCESS_FIELD_DESC); - oprot.writeBool(struct.success); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTask_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 CaptchaTask(); + struct.success.read(iprot); + 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(); + } - private static class hasService_resultTupleSchemeFactory implements SchemeFactory { - public hasService_resultTupleScheme getScheme() { - return new hasService_resultTupleScheme(); - } - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCaptchaTask_result struct) throws org.apache.thrift.TException { + struct.validate(); - private static class hasService_resultTupleScheme extends TupleScheme<hasService_result> { + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + struct.success.write(oprot); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, hasService_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - oprot.writeBool(struct.success); - } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, hasService_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.success = iprot.readBool(); - struct.setSuccessIsSet(true); + private static class getCaptchaTask_resultTupleSchemeFactory implements SchemeFactory { + public getCaptchaTask_resultTupleScheme getScheme() { + return new getCaptchaTask_resultTupleScheme(); + } } - } - } - } + private static class getCaptchaTask_resultTupleScheme extends TupleScheme<getCaptchaTask_result> { - public static class call_args implements org.apache.thrift.TBase<call_args, call_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("call_args"); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + struct.success.write(oprot); + } + } - 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); + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTask_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = new CaptchaTask(); + struct.success.read(iprot); + struct.setSuccessIsSet(true); + } + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new call_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new call_argsTupleSchemeFactory()); } - public ServiceCall 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 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: // 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 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; - } - } + public static class getCaptchaTaskStatus_args implements org.apache.thrift.TBase<getCaptchaTaskStatus_args, getCaptchaTaskStatus_args._Fields>, java.io.Serializable, Cloneable, Comparable<getCaptchaTaskStatus_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTaskStatus_args"); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.INFO, new org.apache.thrift.meta_data.FieldMetaData("info", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ServiceCall.class))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(call_args.class, metaDataMap); - } + private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I32, (short) 1); - public call_args() { - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - public call_args( - ServiceCall info) - { - this(); - this.info = info; - } + static { + schemes.put(StandardScheme.class, new getCaptchaTaskStatus_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCaptchaTaskStatus_argsTupleSchemeFactory()); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public call_args(call_args other) { - if (other.isSetInfo()) { - this.info = new ServiceCall(other.info); - } - } + public int tid; // required - public call_args deepCopy() { - return new call_args(this); - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - @Override - public void clear() { - this.info = null; - } + out.writeInt(tid); + } - public ServiceCall getInfo() { - return this.info; - } + @Override + public int describeContents() { + return 0; + } - public call_args setInfo(ServiceCall info) { - this.info = info; - return this; - } + public getCaptchaTaskStatus_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - public void unsetInfo() { - this.info = null; - } + this.tid = in.readInt(); + } - /** Returns true if field info is set (has been assigned a value) and false otherwise */ - public boolean isSetInfo() { - return this.info != null; - } + public static final android.os.Parcelable.Creator<getCaptchaTaskStatus_args> CREATOR = new android.os.Parcelable.Creator<getCaptchaTaskStatus_args>() { + @Override + public getCaptchaTaskStatus_args[] newArray(int size) { + return new getCaptchaTaskStatus_args[size]; + } - public void setInfoIsSet(boolean value) { - if (!value) { - this.info = null; - } - } + @Override + public getCaptchaTaskStatus_args createFromParcel(android.os.Parcel in) { + return new getCaptchaTaskStatus_args(in); + } + }; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case INFO: - if (value == null) { - unsetInfo(); - } else { - setInfo((ServiceCall)value); - } - break; + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TID((short) 1, "tid"); - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Object getFieldValue(_Fields field) { - switch (field) { - case INFO: - return getInfo(); + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - } - throw new IllegalStateException(); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // TID + return TID; + default: + return null; + } + } - /** 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 INFO: - return isSetInfo(); - } - throw new IllegalStateException(); - } + /** + * 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; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof call_args) - return this.equals((call_args)that); - return false; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public boolean equals(call_args that) { - if (that == null) - return false; + private final short _thriftId; + private final String _fieldName; - 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; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - return true; - } + public short getThriftFieldId() { + return _thriftId; + } - @Override - public int hashCode() { - return 0; - } + public String getFieldName() { + return _fieldName; + } + } - public int compareTo(call_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - call_args typedOther = (call_args)other; - - lastComparison = Boolean.valueOf(isSetInfo()).compareTo(typedOther.isSetInfo()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetInfo()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.info, typedOther.info); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + // isset id assignments + private static final int __TID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "TaskID"))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTaskStatus_args.class, metaDataMap); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public getCaptchaTaskStatus_args() { + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + public getCaptchaTaskStatus_args( + int tid) { + this(); + this.tid = tid; + setTidIsSet(true); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("call_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(); - } + /** + * Performs a deep copy on <i>other</i>. + */ + public getCaptchaTaskStatus_args(getCaptchaTaskStatus_args other) { + __isset_bitfield = other.__isset_bitfield; + this.tid = other.tid; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public getCaptchaTaskStatus_args deepCopy() { + return new getCaptchaTaskStatus_args(this); + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void clear() { + setTidIsSet(false); + this.tid = 0; + } - 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.getMessage()); - } - } + public int getTid() { + return this.tid; + } - private static class call_argsStandardSchemeFactory implements SchemeFactory { - public call_argsStandardScheme getScheme() { - return new call_argsStandardScheme(); - } - } + public getCaptchaTaskStatus_args setTid(int tid) { + this.tid = tid; + setTidIsSet(true); + return this; + } - private static class call_argsStandardScheme extends StandardScheme<call_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, call_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 ServiceCall(); - 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, call_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(); - } + public void unsetTid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TID_ISSET_ID); + } - } + /** Returns true if field tid is set (has been assigned a value) and false otherwise */ + public boolean isSetTid() { + return EncodingUtils.testBit(__isset_bitfield, __TID_ISSET_ID); + } - private static class call_argsTupleSchemeFactory implements SchemeFactory { - public call_argsTupleScheme getScheme() { - return new call_argsTupleScheme(); - } - } + public void setTidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TID_ISSET_ID, value); + } - private static class call_argsTupleScheme extends TupleScheme<call_args> { + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TID: + if (value == null) { + unsetTid(); + } else { + setTid((Integer) value); + } + break; - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, call_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetInfo()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetInfo()) { - struct.info.write(oprot); + } } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, call_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.info = new ServiceCall(); - struct.info.read(iprot); - struct.setInfoIsSet(true); + public Object getFieldValue(_Fields field) { + switch (field) { + case TID: + return getTid(); + + } + 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(); + } - public static class call_result implements org.apache.thrift.TBase<call_result, call_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("call_result"); + switch (field) { + case TID: + return isSetTid(); + } + throw new IllegalStateException(); + } - 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.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1); - private static final org.apache.thrift.protocol.TField E_FIELD_DESC = new org.apache.thrift.protocol.TField("e", org.apache.thrift.protocol.TType.STRUCT, (short)2); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCaptchaTaskStatus_args) + return this.equals((getCaptchaTaskStatus_args) that); + return false; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new call_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new call_resultTupleSchemeFactory()); - } + public boolean equals(getCaptchaTaskStatus_args that) { + if (that == null) + return false; - public String success; // required - public ServiceDoesNotExists ex; // required - public ServiceException e; // 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"), - EX((short)1, "ex"), - E((short)2, "e"); - - 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 0: // SUCCESS - return SUCCESS; - case 1: // EX - return EX; - case 2: // E - return E; - 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; - } - } + boolean this_present_tid = true; + boolean that_present_tid = true; + if (this_present_tid || that_present_tid) { + if (!(this_present_tid && that_present_tid)) + return false; + if (this.tid != that.tid) + return false; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - tmpMap.put(_Fields.E, new org.apache.thrift.meta_data.FieldMetaData("e", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(call_result.class, metaDataMap); - } + return true; + } - public call_result() { - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public call_result( - String success, - ServiceDoesNotExists ex, - ServiceException e) - { - this(); - this.success = success; - this.ex = ex; - this.e = e; - } + boolean present_tid = true; + list.add(present_tid); + if (present_tid) + list.add(tid); - /** - * Performs a deep copy on <i>other</i>. - */ - public call_result(call_result other) { - if (other.isSetSuccess()) { - this.success = other.success; - } - if (other.isSetEx()) { - this.ex = new ServiceDoesNotExists(other.ex); - } - if (other.isSetE()) { - this.e = new ServiceException(other.e); - } - } + return list.hashCode(); + } - public call_result deepCopy() { - return new call_result(this); - } + @Override + public int compareTo(getCaptchaTaskStatus_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - @Override - public void clear() { - this.success = null; - this.ex = null; - this.e = null; - } + int lastComparison = 0; - public String getSuccess() { - return this.success; - } + lastComparison = Boolean.valueOf(isSetTid()).compareTo(other.isSetTid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, other.tid); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public call_result setSuccess(String success) { - this.success = success; - return this; - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - public void unsetSuccess() { - this.success = null; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCaptchaTaskStatus_args("); + boolean first = true; - public ServiceDoesNotExists getEx() { - return this.ex; - } + sb.append("tid:"); + sb.append(this.tid); + first = false; + sb.append(")"); + return sb.toString(); + } - public call_result setEx(ServiceDoesNotExists ex) { - this.ex = ex; - return this; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void unsetEx() { - this.ex = null; - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - /** Returns true if field ex is set (has been assigned a value) and false otherwise */ - public boolean isSetEx() { - return this.ex != null; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - public void setExIsSet(boolean value) { - if (!value) { - this.ex = null; - } - } + private static class getCaptchaTaskStatus_argsStandardSchemeFactory implements SchemeFactory { + public getCaptchaTaskStatus_argsStandardScheme getScheme() { + return new getCaptchaTaskStatus_argsStandardScheme(); + } + } - public ServiceException getE() { - return this.e; - } + private static class getCaptchaTaskStatus_argsStandardScheme extends StandardScheme<getCaptchaTaskStatus_args> { - public call_result setE(ServiceException e) { - this.e = e; - return this; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTaskStatus_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: // TID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.tid = iprot.readI32(); + struct.setTidIsSet(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(); - public void unsetE() { - this.e = null; - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - /** Returns true if field e is set (has been assigned a value) and false otherwise */ - public boolean isSetE() { - return this.e != null; - } + public void write(org.apache.thrift.protocol.TProtocol oprot, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { + struct.validate(); - public void setEIsSet(boolean value) { - if (!value) { - this.e = null; - } - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TID_FIELD_DESC); + oprot.writeI32(struct.tid); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((String)value); } - break; - case EX: - if (value == null) { - unsetEx(); - } else { - setEx((ServiceDoesNotExists)value); + private static class getCaptchaTaskStatus_argsTupleSchemeFactory implements SchemeFactory { + public getCaptchaTaskStatus_argsTupleScheme getScheme() { + return new getCaptchaTaskStatus_argsTupleScheme(); + } } - break; - case E: - if (value == null) { - unsetE(); - } else { - setE((ServiceException)value); + private static class getCaptchaTaskStatus_argsTupleScheme extends TupleScheme<getCaptchaTaskStatus_args> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTid()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetTid()) { + oprot.writeI32(struct.tid); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.tid = iprot.readI32(); + struct.setTidIsSet(true); + } + } } - break; - } } - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); - - case EX: - return getEx(); + public static class getCaptchaTaskStatus_result implements org.apache.thrift.TBase<getCaptchaTaskStatus_result, getCaptchaTaskStatus_result._Fields>, java.io.Serializable, Cloneable, Comparable<getCaptchaTaskStatus_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getCaptchaTaskStatus_result"); - case E: - return getE(); + 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); - } - throw new IllegalStateException(); - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - case EX: - return isSetEx(); - case E: - return isSetE(); - } - throw new IllegalStateException(); - } + static { + schemes.put(StandardScheme.class, new getCaptchaTaskStatus_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new getCaptchaTaskStatus_resultTupleSchemeFactory()); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof call_result) - return this.equals((call_result)that); - return false; - } + public String success; // required - public boolean equals(call_result that) { - if (that == null) - return false; - - boolean this_present_success = true && this.isSetSuccess(); - boolean that_present_success = true && that.isSetSuccess(); - if (this_present_success || that_present_success) { - if (!(this_present_success && that_present_success)) - return false; - if (!this.success.equals(that.success)) - return false; - } - - boolean this_present_ex = true && this.isSetEx(); - boolean that_present_ex = true && that.isSetEx(); - if (this_present_ex || that_present_ex) { - if (!(this_present_ex && that_present_ex)) - return false; - if (!this.ex.equals(that.ex)) - return false; - } - - boolean this_present_e = true && this.isSetE(); - boolean that_present_e = true && that.isSetE(); - if (this_present_e || that_present_e) { - if (!(this_present_e && that_present_e)) - return false; - if (!this.e.equals(that.e)) - return false; - } - - return true; - } + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(success); + } - @Override - public int hashCode() { - return 0; - } + @Override + public int describeContents() { + return 0; + } - public int compareTo(call_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - call_result typedOther = (call_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetEx()).compareTo(typedOther.isSetEx()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEx()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ex, typedOther.ex); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetE()).compareTo(typedOther.isSetE()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetE()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.e, typedOther.e); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public getCaptchaTaskStatus_result(android.os.Parcel in) { + this.success = in.readString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public static final android.os.Parcelable.Creator<getCaptchaTaskStatus_result> CREATOR = new android.os.Parcelable.Creator<getCaptchaTaskStatus_result>() { + @Override + public getCaptchaTaskStatus_result[] newArray(int size) { + return new getCaptchaTaskStatus_result[size]; + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + @Override + public getCaptchaTaskStatus_result createFromParcel(android.os.Parcel in) { + return new getCaptchaTaskStatus_result(in); + } + }; - 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("call_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("ex:"); - if (this.ex == null) { - sb.append("null"); - } else { - sb.append(this.ex); - } - first = false; - if (!first) sb.append(", "); - sb.append("e:"); - if (this.e == null) { - sb.append("null"); - } else { - sb.append(this.e); - } - first = false; - sb.append(")"); - return sb.toString(); - } + /** 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"); - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - 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.getMessage()); - } - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 0: // SUCCESS + return SUCCESS; + default: + return null; + } + } - private static class call_resultStandardSchemeFactory implements SchemeFactory { - public call_resultStandardScheme getScheme() { - return new call_resultStandardScheme(); - } - } + /** + * 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; + } - private static class call_resultStandardScheme extends StandardScheme<call_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, call_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; - case 1: // EX - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.ex = new ServiceDoesNotExists(); - struct.ex.read(iprot); - struct.setExIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // E - if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) { - struct.e = new ServiceException(); - struct.e.read(iprot); - struct.setEIsSet(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, call_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(); - } - if (struct.ex != null) { - oprot.writeFieldBegin(EX_FIELD_DESC); - struct.ex.write(oprot); - oprot.writeFieldEnd(); - } - if (struct.e != null) { - oprot.writeFieldBegin(E_FIELD_DESC); - struct.e.write(oprot); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + /** + * 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; - private static class call_resultTupleSchemeFactory implements SchemeFactory { - public call_resultTupleScheme getScheme() { - return new call_resultTupleScheme(); - } - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - private static class call_resultTupleScheme extends TupleScheme<call_result> { + public short getThriftFieldId() { + return _thriftId; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, call_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - if (struct.isSetEx()) { - optionals.set(1); - } - if (struct.isSetE()) { - optionals.set(2); + public String getFieldName() { + return _fieldName; + } } - oprot.writeBitSet(optionals, 3); - if (struct.isSetSuccess()) { - oprot.writeString(struct.success); + + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; + + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getCaptchaTaskStatus_result.class, metaDataMap); } - if (struct.isSetEx()) { - struct.ex.write(oprot); + + public getCaptchaTaskStatus_result() { } - if (struct.isSetE()) { - struct.e.write(oprot); + + public getCaptchaTaskStatus_result( + String success) { + this(); + this.success = success; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, call_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(3); - if (incoming.get(0)) { - struct.success = iprot.readString(); - struct.setSuccessIsSet(true); + /** + * Performs a deep copy on <i>other</i>. + */ + public getCaptchaTaskStatus_result(getCaptchaTaskStatus_result other) { + if (other.isSetSuccess()) { + this.success = other.success; + } } - if (incoming.get(1)) { - struct.ex = new ServiceDoesNotExists(); - struct.ex.read(iprot); - struct.setExIsSet(true); + + public getCaptchaTaskStatus_result deepCopy() { + return new getCaptchaTaskStatus_result(this); } - if (incoming.get(2)) { - struct.e = new ServiceException(); - struct.e.read(iprot); - struct.setEIsSet(true); + + @Override + public void clear() { + this.success = null; } - } - } - } + public String getSuccess() { + return this.success; + } - public static class getAllInfo_args implements org.apache.thrift.TBase<getAllInfo_args, getAllInfo_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllInfo_args"); + public getCaptchaTaskStatus_result setSuccess(String success) { + this.success = success; + return this; + } + public void unsetSuccess() { + this.success = null; + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAllInfo_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAllInfo_argsTupleSchemeFactory()); - } + /** 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; + } + } - /** 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 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) { - 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; - } - } - 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); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllInfo_args.class, metaDataMap); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case SUCCESS: + if (value == null) { + unsetSuccess(); + } else { + setSuccess((String) value); + } + break; - public getAllInfo_args() { - } + } + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getAllInfo_args(getAllInfo_args other) { - } + public Object getFieldValue(_Fields field) { + switch (field) { + case SUCCESS: + return getSuccess(); - public getAllInfo_args deepCopy() { - return new getAllInfo_args(this); - } + } + throw new IllegalStateException(); + } - @Override - public void clear() { - } + /** 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(); + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - } - } + switch (field) { + case SUCCESS: + return isSetSuccess(); + } + throw new IllegalStateException(); + } - public Object getFieldValue(_Fields field) { - switch (field) { - } - throw new IllegalStateException(); - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof getCaptchaTaskStatus_result) + return this.equals((getCaptchaTaskStatus_result) that); + return false; + } - /** 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(); - } + public boolean equals(getCaptchaTaskStatus_result that) { + if (that == null) + return false; - switch (field) { - } - throw new IllegalStateException(); - } + 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; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAllInfo_args) - return this.equals((getAllInfo_args)that); - return false; - } + return true; + } - public boolean equals(getAllInfo_args that) { - if (that == null) - return false; + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - return true; - } + boolean present_success = true && (isSetSuccess()); + list.add(present_success); + if (present_success) + list.add(success); - @Override - public int hashCode() { - return 0; - } + return list.hashCode(); + } - public int compareTo(getAllInfo_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } + @Override + public int compareTo(getCaptchaTaskStatus_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - int lastComparison = 0; - getAllInfo_args typedOther = (getAllInfo_args)other; + int lastComparison = 0; - return 0; - } + lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(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; + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + 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 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); - } + 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("getAllInfo_args("); - boolean first = true; + @Override + public String toString() { + StringBuilder sb = new StringBuilder("getCaptchaTaskStatus_result("); + boolean first = true; - sb.append(")"); - return sb.toString(); - } + 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 - } + 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.getMessage()); - } - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(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.getMessage()); - } - } + 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 getAllInfo_argsStandardSchemeFactory implements SchemeFactory { - public getAllInfo_argsStandardScheme getScheme() { - return new getAllInfo_argsStandardScheme(); - } - } + private static class getCaptchaTaskStatus_resultStandardSchemeFactory implements SchemeFactory { + public getCaptchaTaskStatus_resultStandardScheme getScheme() { + return new getCaptchaTaskStatus_resultStandardScheme(); + } + } - private static class getAllInfo_argsStandardScheme extends StandardScheme<getAllInfo_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAllInfo_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, getAllInfo_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + private static class getCaptchaTaskStatus_resultStandardScheme extends StandardScheme<getCaptchaTaskStatus_result> { - } + public void read(org.apache.thrift.protocol.TProtocol iprot, getCaptchaTaskStatus_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(); - private static class getAllInfo_argsTupleSchemeFactory implements SchemeFactory { - public getAllInfo_argsTupleScheme getScheme() { - return new getAllInfo_argsTupleScheme(); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static class getAllInfo_argsTupleScheme extends TupleScheme<getAllInfo_args> { + public void write(org.apache.thrift.protocol.TProtocol oprot, getCaptchaTaskStatus_result struct) throws org.apache.thrift.TException { + struct.validate(); - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAllInfo_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - } + oprot.writeStructBegin(STRUCT_DESC); + if (struct.success != null) { + oprot.writeFieldBegin(SUCCESS_FIELD_DESC); + oprot.writeString(struct.success); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAllInfo_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - } - } + } - } + private static class getCaptchaTaskStatus_resultTupleSchemeFactory implements SchemeFactory { + public getCaptchaTaskStatus_resultTupleScheme getScheme() { + return new getCaptchaTaskStatus_resultTupleScheme(); + } + } - public static class getAllInfo_result implements org.apache.thrift.TBase<getAllInfo_result, getAllInfo_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllInfo_result"); + private static class getCaptchaTaskStatus_resultTupleScheme extends TupleScheme<getCaptchaTaskStatus_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); + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetSuccess()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetSuccess()) { + oprot.writeString(struct.success); + } + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getAllInfo_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getAllInfo_resultTupleSchemeFactory()); - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, getCaptchaTaskStatus_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.success = iprot.readString(); + struct.setSuccessIsSet(true); + } + } + } - public Map<String,Map<String,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 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 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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); - return fields; - } - - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"), - 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(getAllInfo_result.class, metaDataMap); - } + public static class setCaptchaResult_args implements org.apache.thrift.TBase<setCaptchaResult_args, setCaptchaResult_args._Fields>, java.io.Serializable, Cloneable, Comparable<setCaptchaResult_args>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setCaptchaResult_args"); - public getAllInfo_result() { - } + private static final org.apache.thrift.protocol.TField TID_FIELD_DESC = new org.apache.thrift.protocol.TField("tid", org.apache.thrift.protocol.TType.I32, (short) 1); + private static final org.apache.thrift.protocol.TField RESULT_FIELD_DESC = new org.apache.thrift.protocol.TField("result", org.apache.thrift.protocol.TType.STRING, (short) 2); - public getAllInfo_result( - Map<String,Map<String,String>> success) - { - this(); - this.success = success; - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - /** - * Performs a deep copy on <i>other</i>. - */ - public getAllInfo_result(getAllInfo_result other) { - if (other.isSetSuccess()) { - Map<String,Map<String,String>> __this__success = new HashMap<String,Map<String,String>>(); - for (Map.Entry<String, Map<String,String>> other_element : other.success.entrySet()) { + static { + schemes.put(StandardScheme.class, new setCaptchaResult_argsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setCaptchaResult_argsTupleSchemeFactory()); + } - String other_element_key = other_element.getKey(); - Map<String,String> other_element_value = other_element.getValue(); + public int tid; // required + public String result; // required - String __this__success_copy_key = other_element_key; + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); - Map<String,String> __this__success_copy_value = new HashMap<String,String>(); - for (Map.Entry<String, String> other_element_value_element : other_element_value.entrySet()) { + out.writeInt(tid); + out.writeString(result); + } - String other_element_value_element_key = other_element_value_element.getKey(); - String other_element_value_element_value = other_element_value_element.getValue(); + @Override + public int describeContents() { + return 0; + } - String __this__success_copy_value_copy_key = other_element_value_element_key; + public setCaptchaResult_args(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); - String __this__success_copy_value_copy_value = other_element_value_element_value; + this.tid = in.readInt(); + this.result = in.readString(); + } - __this__success_copy_value.put(__this__success_copy_value_copy_key, __this__success_copy_value_copy_value); - } + public static final android.os.Parcelable.Creator<setCaptchaResult_args> CREATOR = new android.os.Parcelable.Creator<setCaptchaResult_args>() { + @Override + public setCaptchaResult_args[] newArray(int size) { + return new setCaptchaResult_args[size]; + } - __this__success.put(__this__success_copy_key, __this__success_copy_value); - } - this.success = __this__success; - } - } + @Override + public setCaptchaResult_args createFromParcel(android.os.Parcel in) { + return new setCaptchaResult_args(in); + } + }; - public getAllInfo_result deepCopy() { - return new getAllInfo_result(this); - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + TID((short) 1, "tid"), + RESULT((short) 2, "result"); - @Override - public void clear() { - this.success = null; - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public void putToSuccess(String key, Map<String,String> val) { - if (this.success == null) { - this.success = new HashMap<String,Map<String,String>>(); - } - this.success.put(key, val); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // TID + return TID; + case 2: // RESULT + return RESULT; + default: + return null; + } + } - public Map<String,Map<String,String>> getSuccess() { - return this.success; - } + /** + * 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; + } - public getAllInfo_result setSuccess(Map<String,Map<String,String>> success) { - this.success = success; - return this; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public void unsetSuccess() { - this.success = null; - } + private final short _thriftId; + private final String _fieldName; - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + public short getThriftFieldId() { + return _thriftId; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,Map<String,String>>)value); + public String getFieldName() { + return _fieldName; + } } - break; - } - } + // isset id assignments + private static final int __TID_ISSET_ID = 0; + private byte __isset_bitfield = 0; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.TID, new org.apache.thrift.meta_data.FieldMetaData("tid", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32, "TaskID"))); + tmpMap.put(_Fields.RESULT, new org.apache.thrift.meta_data.FieldMetaData("result", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setCaptchaResult_args.class, metaDataMap); + } - } - throw new IllegalStateException(); - } + public setCaptchaResult_args() { + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + public setCaptchaResult_args( + int tid, + String result) { + this(); + this.tid = tid; + setTidIsSet(true); + this.result = result; + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getAllInfo_result) - return this.equals((getAllInfo_result)that); - return false; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public setCaptchaResult_args(setCaptchaResult_args other) { + __isset_bitfield = other.__isset_bitfield; + this.tid = other.tid; + if (other.isSetResult()) { + this.result = other.result; + } + } - public boolean equals(getAllInfo_result that) { - if (that == null) - return false; + public setCaptchaResult_args deepCopy() { + return new setCaptchaResult_args(this); + } - 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; - } + @Override + public void clear() { + setTidIsSet(false); + this.tid = 0; + this.result = null; + } - return true; - } + public int getTid() { + return this.tid; + } - @Override - public int hashCode() { - return 0; - } + public setCaptchaResult_args setTid(int tid) { + this.tid = tid; + setTidIsSet(true); + return this; + } - public int compareTo(getAllInfo_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getAllInfo_result typedOther = (getAllInfo_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void unsetTid() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TID_ISSET_ID); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + /** Returns true if field tid is set (has been assigned a value) and false otherwise */ + public boolean isSetTid() { + return EncodingUtils.testBit(__isset_bitfield, __TID_ISSET_ID); + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + public void setTidIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TID_ISSET_ID, value); + } - 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("getAllInfo_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 String getResult() { + return this.result; + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public setCaptchaResult_args setResult(String result) { + this.result = result; + return this; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + public void unsetResult() { + this.result = null; + } - 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.getMessage()); - } - } + /** Returns true if field result is set (has been assigned a value) and false otherwise */ + public boolean isSetResult() { + return this.result != null; + } - private static class getAllInfo_resultStandardSchemeFactory implements SchemeFactory { - public getAllInfo_resultStandardScheme getScheme() { - return new getAllInfo_resultStandardScheme(); - } - } + public void setResultIsSet(boolean value) { + if (!value) { + this.result = null; + } + } - private static class getAllInfo_resultStandardScheme extends StandardScheme<getAllInfo_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getAllInfo_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 _map380 = iprot.readMapBegin(); - struct.success = new HashMap<String,Map<String,String>>(2*_map380.size); - for (int _i381 = 0; _i381 < _map380.size; ++_i381) - { - String _key382; // required - Map<String,String> _val383; // required - _key382 = iprot.readString(); - { - org.apache.thrift.protocol.TMap _map384 = iprot.readMapBegin(); - _val383 = new HashMap<String,String>(2*_map384.size); - for (int _i385 = 0; _i385 < _map384.size; ++_i385) - { - String _key386; // required - String _val387; // required - _key386 = iprot.readString(); - _val387 = iprot.readString(); - _val383.put(_key386, _val387); - } - iprot.readMapEnd(); - } - struct.success.put(_key382, _val383); - } - iprot.readMapEnd(); - } - 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, getAllInfo_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.MAP, struct.success.size())); - for (Map.Entry<String, Map<String,String>> _iter388 : struct.success.entrySet()) - { - oprot.writeString(_iter388.getKey()); - { - oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter388.getValue().size())); - for (Map.Entry<String, String> _iter389 : _iter388.getValue().entrySet()) - { - oprot.writeString(_iter389.getKey()); - oprot.writeString(_iter389.getValue()); - } - oprot.writeMapEnd(); - } - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case TID: + if (value == null) { + unsetTid(); + } else { + setTid((Integer) value); + } + break; - } + case RESULT: + if (value == null) { + unsetResult(); + } else { + setResult((String) value); + } + break; - private static class getAllInfo_resultTupleSchemeFactory implements SchemeFactory { - public getAllInfo_resultTupleScheme getScheme() { - return new getAllInfo_resultTupleScheme(); - } - } + } + } - private static class getAllInfo_resultTupleScheme extends TupleScheme<getAllInfo_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getAllInfo_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, Map<String,String>> _iter390 : struct.success.entrySet()) - { - oprot.writeString(_iter390.getKey()); - { - oprot.writeI32(_iter390.getValue().size()); - for (Map.Entry<String, String> _iter391 : _iter390.getValue().entrySet()) - { - oprot.writeString(_iter391.getKey()); - oprot.writeString(_iter391.getValue()); - } - } - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getAllInfo_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map392 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.MAP, iprot.readI32()); - struct.success = new HashMap<String,Map<String,String>>(2*_map392.size); - for (int _i393 = 0; _i393 < _map392.size; ++_i393) - { - String _key394; // required - Map<String,String> _val395; // required - _key394 = iprot.readString(); - { - org.apache.thrift.protocol.TMap _map396 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - _val395 = new HashMap<String,String>(2*_map396.size); - for (int _i397 = 0; _i397 < _map396.size; ++_i397) - { - String _key398; // required - String _val399; // required - _key398 = iprot.readString(); - _val399 = iprot.readString(); - _val395.put(_key398, _val399); - } - } - struct.success.put(_key394, _val395); - } - } - struct.setSuccessIsSet(true); - } - } - } + public Object getFieldValue(_Fields field) { + switch (field) { + case TID: + return getTid(); - } + case RESULT: + return getResult(); - public static class getInfoByPlugin_args implements org.apache.thrift.TBase<getInfoByPlugin_args, getInfoByPlugin_args._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getInfoByPlugin_args"); + } + throw new IllegalStateException(); + } - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); + /** 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(); + } - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getInfoByPlugin_argsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getInfoByPlugin_argsTupleSchemeFactory()); - } + switch (field) { + case TID: + return isSetTid(); + case RESULT: + return isSetResult(); + } + throw new IllegalStateException(); + } - public String plugin; // 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 { - PLUGIN((short)1, "plugin"); - - 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: // PLUGIN - return PLUGIN; - 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; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setCaptchaResult_args) + return this.equals((setCaptchaResult_args) that); + return false; + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getInfoByPlugin_args.class, metaDataMap); - } + public boolean equals(setCaptchaResult_args that) { + if (that == null) + return false; - public getInfoByPlugin_args() { - } + boolean this_present_tid = true; + boolean that_present_tid = true; + if (this_present_tid || that_present_tid) { + if (!(this_present_tid && that_present_tid)) + return false; + if (this.tid != that.tid) + return false; + } - public getInfoByPlugin_args( - String plugin) - { - this(); - this.plugin = plugin; - } + boolean this_present_result = true && this.isSetResult(); + boolean that_present_result = true && that.isSetResult(); + if (this_present_result || that_present_result) { + if (!(this_present_result && that_present_result)) + return false; + if (!this.result.equals(that.result)) + return false; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getInfoByPlugin_args(getInfoByPlugin_args other) { - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - } + return true; + } - public getInfoByPlugin_args deepCopy() { - return new getInfoByPlugin_args(this); - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - @Override - public void clear() { - this.plugin = null; - } + boolean present_tid = true; + list.add(present_tid); + if (present_tid) + list.add(tid); - public String getPlugin() { - return this.plugin; - } + boolean present_result = true && (isSetResult()); + list.add(present_result); + if (present_result) + list.add(result); - public getInfoByPlugin_args setPlugin(String plugin) { - this.plugin = plugin; - return this; - } + return list.hashCode(); + } - public void unsetPlugin() { - this.plugin = null; - } + @Override + public int compareTo(setCaptchaResult_args other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } + int lastComparison = 0; - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } + lastComparison = Boolean.valueOf(isSetTid()).compareTo(other.isSetTid()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTid()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.tid, other.tid); + if (lastComparison != 0) { + return lastComparison; + } + } + lastComparison = Boolean.valueOf(isSetResult()).compareTo(other.isSetResult()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetResult()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.result, other.result); + if (lastComparison != 0) { + return lastComparison; + } + } + return 0; + } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - break; - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - } - throw new IllegalStateException(); - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("setCaptchaResult_args("); + boolean first = true; - /** 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 PLUGIN: - return isSetPlugin(); - } - throw new IllegalStateException(); - } + sb.append("tid:"); + sb.append(this.tid); + first = false; + if (!first) sb.append(", "); + sb.append("result:"); + if (this.result == null) { + sb.append("null"); + } else { + sb.append(this.result); + } + first = false; + sb.append(")"); + return sb.toString(); + } - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getInfoByPlugin_args) - return this.equals((getInfoByPlugin_args)that); - return false; - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public boolean equals(getInfoByPlugin_args that) { - if (that == null) - return false; + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. + __isset_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); + } + } - return true; - } + private static class setCaptchaResult_argsStandardSchemeFactory implements SchemeFactory { + public setCaptchaResult_argsStandardScheme getScheme() { + return new setCaptchaResult_argsStandardScheme(); + } + } - @Override - public int hashCode() { - return 0; - } + private static class setCaptchaResult_argsStandardScheme extends StandardScheme<setCaptchaResult_args> { - public int compareTo(getInfoByPlugin_args other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getInfoByPlugin_args typedOther = (getInfoByPlugin_args)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + public void read(org.apache.thrift.protocol.TProtocol iprot, setCaptchaResult_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: // TID + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.tid = iprot.readI32(); + struct.setTidIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // RESULT + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.result = iprot.readString(); + struct.setResultIsSet(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(); - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - 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, setCaptchaResult_args struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(TID_FIELD_DESC); + oprot.writeI32(struct.tid); + oprot.writeFieldEnd(); + if (struct.result != null) { + oprot.writeFieldBegin(RESULT_FIELD_DESC); + oprot.writeString(struct.result); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - 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("getInfoByPlugin_args("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - sb.append(")"); - return sb.toString(); - } + private static class setCaptchaResult_argsTupleSchemeFactory implements SchemeFactory { + public setCaptchaResult_argsTupleScheme getScheme() { + return new setCaptchaResult_argsTupleScheme(); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class setCaptchaResult_argsTupleScheme extends TupleScheme<setCaptchaResult_args> { - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_args struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetTid()) { + optionals.set(0); + } + if (struct.isSetResult()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetTid()) { + oprot.writeI32(struct.tid); + } + if (struct.isSetResult()) { + oprot.writeString(struct.result); + } + } - 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.getMessage()); - } - } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_args struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.tid = iprot.readI32(); + struct.setTidIsSet(true); + } + if (incoming.get(1)) { + struct.result = iprot.readString(); + struct.setResultIsSet(true); + } + } + } - private static class getInfoByPlugin_argsStandardSchemeFactory implements SchemeFactory { - public getInfoByPlugin_argsStandardScheme getScheme() { - return new getInfoByPlugin_argsStandardScheme(); - } } - private static class getInfoByPlugin_argsStandardScheme extends StandardScheme<getInfoByPlugin_args> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getInfoByPlugin_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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(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, getInfoByPlugin_args struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public static class setCaptchaResult_result implements org.apache.thrift.TBase<setCaptchaResult_result, setCaptchaResult_result._Fields>, java.io.Serializable, Cloneable, Comparable<setCaptchaResult_result>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("setCaptchaResult_result"); - } - private static class getInfoByPlugin_argsTupleSchemeFactory implements SchemeFactory { - public getInfoByPlugin_argsTupleScheme getScheme() { - return new getInfoByPlugin_argsTupleScheme(); - } - } + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new setCaptchaResult_resultStandardSchemeFactory()); + schemes.put(TupleScheme.class, new setCaptchaResult_resultTupleSchemeFactory()); + } - private static class getInfoByPlugin_argsTupleScheme extends TupleScheme<getInfoByPlugin_args> { - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_args struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); + @Override + public void writeToParcel(android.os.Parcel out, int flags) { } - oprot.writeBitSet(optionals, 1); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); + + @Override + public int describeContents() { + return 0; } - } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_args struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); + public setCaptchaResult_result(android.os.Parcel in) { } - } - } - } + public static final android.os.Parcelable.Creator<setCaptchaResult_result> CREATOR = new android.os.Parcelable.Creator<setCaptchaResult_result>() { + @Override + public setCaptchaResult_result[] newArray(int size) { + return new setCaptchaResult_result[size]; + } - public static class getInfoByPlugin_result implements org.apache.thrift.TBase<getInfoByPlugin_result, getInfoByPlugin_result._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getInfoByPlugin_result"); + @Override + public setCaptchaResult_result createFromParcel(android.os.Parcel in) { + return new setCaptchaResult_result(in); + } + }; - 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); + /** 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 Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new getInfoByPlugin_resultStandardSchemeFactory()); - schemes.put(TupleScheme.class, new getInfoByPlugin_resultTupleSchemeFactory()); - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - public Map<String,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 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 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 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; - } - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.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(getInfoByPlugin_result.class, metaDataMap); - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + default: + return null; + } + } - public getInfoByPlugin_result() { - } + /** + * 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; + } - public getInfoByPlugin_result( - Map<String,String> success) - { - this(); - this.success = success; - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - /** - * Performs a deep copy on <i>other</i>. - */ - public getInfoByPlugin_result(getInfoByPlugin_result other) { - if (other.isSetSuccess()) { - Map<String,String> __this__success = new HashMap<String,String>(); - for (Map.Entry<String, String> other_element : other.success.entrySet()) { + private final short _thriftId; + private final String _fieldName; - String other_element_key = other_element.getKey(); - String other_element_value = other_element.getValue(); + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } - String __this__success_copy_key = other_element_key; + public String getFieldName() { + return _fieldName; + } + } - String __this__success_copy_value = other_element_value; + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - __this__success.put(__this__success_copy_key, __this__success_copy_value); + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(setCaptchaResult_result.class, metaDataMap); } - this.success = __this__success; - } - } - public getInfoByPlugin_result deepCopy() { - return new getInfoByPlugin_result(this); - } + public setCaptchaResult_result() { + } - @Override - public void clear() { - this.success = null; - } + /** + * Performs a deep copy on <i>other</i>. + */ + public setCaptchaResult_result(setCaptchaResult_result other) { + } - public int getSuccessSize() { - return (this.success == null) ? 0 : this.success.size(); - } + public setCaptchaResult_result deepCopy() { + return new setCaptchaResult_result(this); + } - public void putToSuccess(String key, String val) { - if (this.success == null) { - this.success = new HashMap<String,String>(); - } - this.success.put(key, val); - } + @Override + public void clear() { + } - public Map<String,String> getSuccess() { - return this.success; - } + public void setFieldValue(_Fields field, Object value) { + switch (field) { + } + } - public getInfoByPlugin_result setSuccess(Map<String,String> success) { - this.success = success; - return this; - } + public Object getFieldValue(_Fields field) { + switch (field) { + } + throw new IllegalStateException(); + } - public void unsetSuccess() { - this.success = null; - } + /** 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(); + } - /** Returns true if field success is set (has been assigned a value) and false otherwise */ - public boolean isSetSuccess() { - return this.success != null; - } + switch (field) { + } + throw new IllegalStateException(); + } - public void setSuccessIsSet(boolean value) { - if (!value) { - this.success = null; - } - } + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof setCaptchaResult_result) + return this.equals((setCaptchaResult_result) that); + return false; + } + + public boolean equals(setCaptchaResult_result that) { + if (that == null) + return false; - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case SUCCESS: - if (value == null) { - unsetSuccess(); - } else { - setSuccess((Map<String,String>)value); + return true; } - break; - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); - public Object getFieldValue(_Fields field) { - switch (field) { - case SUCCESS: - return getSuccess(); + return list.hashCode(); + } - } - throw new IllegalStateException(); - } + @Override + public int compareTo(setCaptchaResult_result other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ - public boolean isSet(_Fields field) { - if (field == null) { - throw new IllegalArgumentException(); - } - - switch (field) { - case SUCCESS: - return isSetSuccess(); - } - throw new IllegalStateException(); - } + int lastComparison = 0; - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof getInfoByPlugin_result) - return this.equals((getInfoByPlugin_result)that); - return false; - } + return 0; + } - public boolean equals(getInfoByPlugin_result that) { - if (that == null) - return false; + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - 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; - } + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - return true; - } + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - @Override - public int hashCode() { - return 0; - } + @Override + public String toString() { + StringBuilder sb = new StringBuilder("setCaptchaResult_result("); + boolean first = true; - public int compareTo(getInfoByPlugin_result other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - getInfoByPlugin_result typedOther = (getInfoByPlugin_result)other; - - lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSuccess()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success); - if (lastComparison != 0) { - return lastComparison; - } - } - return 0; - } + sb.append(")"); + return sb.toString(); + } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - 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("getInfoByPlugin_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(); - } + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + private static class setCaptchaResult_resultStandardSchemeFactory implements SchemeFactory { + public setCaptchaResult_resultStandardScheme getScheme() { + return new setCaptchaResult_resultStandardScheme(); + } + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } + private static class setCaptchaResult_resultStandardScheme extends StandardScheme<setCaptchaResult_result> { - 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.getMessage()); - } - } + public void read(org.apache.thrift.protocol.TProtocol iprot, setCaptchaResult_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) { + default: + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + iprot.readFieldEnd(); + } + iprot.readStructEnd(); - private static class getInfoByPlugin_resultStandardSchemeFactory implements SchemeFactory { - public getInfoByPlugin_resultStandardScheme getScheme() { - return new getInfoByPlugin_resultStandardScheme(); - } - } + // check for required fields of primitive type, which can't be checked in the validate method + struct.validate(); + } - private static class getInfoByPlugin_resultStandardScheme extends StandardScheme<getInfoByPlugin_result> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, getInfoByPlugin_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 _map400 = iprot.readMapBegin(); - struct.success = new HashMap<String,String>(2*_map400.size); - for (int _i401 = 0; _i401 < _map400.size; ++_i401) - { - String _key402; // required - String _val403; // required - _key402 = iprot.readString(); - _val403 = iprot.readString(); - struct.success.put(_key402, _val403); - } - iprot.readMapEnd(); - } - 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, getInfoByPlugin_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.STRING, struct.success.size())); - for (Map.Entry<String, String> _iter404 : struct.success.entrySet()) - { - oprot.writeString(_iter404.getKey()); - oprot.writeString(_iter404.getValue()); - } - oprot.writeMapEnd(); - } - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } + public void write(org.apache.thrift.protocol.TProtocol oprot, setCaptchaResult_result struct) throws org.apache.thrift.TException { + struct.validate(); - } + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } - private static class getInfoByPlugin_resultTupleSchemeFactory implements SchemeFactory { - public getInfoByPlugin_resultTupleScheme getScheme() { - return new getInfoByPlugin_resultTupleScheme(); - } - } + } - private static class getInfoByPlugin_resultTupleScheme extends TupleScheme<getInfoByPlugin_result> { - - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_result struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetSuccess()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetSuccess()) { - { - oprot.writeI32(struct.success.size()); - for (Map.Entry<String, String> _iter405 : struct.success.entrySet()) - { - oprot.writeString(_iter405.getKey()); - oprot.writeString(_iter405.getValue()); - } - } - } - } - - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, getInfoByPlugin_result struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - { - org.apache.thrift.protocol.TMap _map406 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.success = new HashMap<String,String>(2*_map406.size); - for (int _i407 = 0; _i407 < _map406.size; ++_i407) - { - String _key408; // required - String _val409; // required - _key408 = iprot.readString(); - _val409 = iprot.readString(); - struct.success.put(_key408, _val409); - } - } - struct.setSuccessIsSet(true); - } - } - } + private static class setCaptchaResult_resultTupleSchemeFactory implements SchemeFactory { + public setCaptchaResult_resultTupleScheme getScheme() { + return new setCaptchaResult_resultTupleScheme(); + } + } + + private static class setCaptchaResult_resultTupleScheme extends TupleScheme<setCaptchaResult_result> { - } + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_result struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + } + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, setCaptchaResult_result struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ServerStatus.java b/app/src/main/java/org/pyload/thrift/ServerStatus.java index 4a976a5..1465eba 100644 --- a/app/src/main/java/org/pyload/thrift/ServerStatus.java +++ b/app/src/main/java/org/pyload/thrift/ServerStatus.java @@ -1,945 +1,1024 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class ServerStatus implements org.apache.thrift.TBase<ServerStatus, ServerStatus._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServerStatus"); - - private static final org.apache.thrift.protocol.TField PAUSE_FIELD_DESC = new org.apache.thrift.protocol.TField("pause", org.apache.thrift.protocol.TType.BOOL, (short)1); - private static final org.apache.thrift.protocol.TField ACTIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("active", org.apache.thrift.protocol.TType.I16, (short)2); - private static final org.apache.thrift.protocol.TField QUEUE_FIELD_DESC = new org.apache.thrift.protocol.TField("queue", org.apache.thrift.protocol.TType.I16, (short)3); - private static final org.apache.thrift.protocol.TField TOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("total", org.apache.thrift.protocol.TType.I16, (short)4); - private static final org.apache.thrift.protocol.TField SPEED_FIELD_DESC = new org.apache.thrift.protocol.TField("speed", org.apache.thrift.protocol.TType.I64, (short)5); - private static final org.apache.thrift.protocol.TField DOWNLOAD_FIELD_DESC = new org.apache.thrift.protocol.TField("download", org.apache.thrift.protocol.TType.BOOL, (short)6); - private static final org.apache.thrift.protocol.TField RECONNECT_FIELD_DESC = new org.apache.thrift.protocol.TField("reconnect", org.apache.thrift.protocol.TType.BOOL, (short)7); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ServerStatusStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ServerStatusTupleSchemeFactory()); - } - - public boolean pause; // required - public short active; // required - public short queue; // required - public short total; // required - public long speed; // required - public boolean download; // required - public boolean reconnect; // 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 { - PAUSE((short)1, "pause"), - ACTIVE((short)2, "active"), - QUEUE((short)3, "queue"), - TOTAL((short)4, "total"), - SPEED((short)5, "speed"), - DOWNLOAD((short)6, "download"), - RECONNECT((short)7, "reconnect"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ServerStatus implements org.apache.thrift.TBase<ServerStatus, ServerStatus._Fields>, java.io.Serializable, Cloneable, Comparable<ServerStatus>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServerStatus"); + + private static final org.apache.thrift.protocol.TField PAUSE_FIELD_DESC = new org.apache.thrift.protocol.TField("pause", org.apache.thrift.protocol.TType.BOOL, (short) 1); + private static final org.apache.thrift.protocol.TField ACTIVE_FIELD_DESC = new org.apache.thrift.protocol.TField("active", org.apache.thrift.protocol.TType.I16, (short) 2); + private static final org.apache.thrift.protocol.TField QUEUE_FIELD_DESC = new org.apache.thrift.protocol.TField("queue", org.apache.thrift.protocol.TType.I16, (short) 3); + private static final org.apache.thrift.protocol.TField TOTAL_FIELD_DESC = new org.apache.thrift.protocol.TField("total", org.apache.thrift.protocol.TType.I16, (short) 4); + private static final org.apache.thrift.protocol.TField SPEED_FIELD_DESC = new org.apache.thrift.protocol.TField("speed", org.apache.thrift.protocol.TType.I64, (short) 5); + private static final org.apache.thrift.protocol.TField DOWNLOAD_FIELD_DESC = new org.apache.thrift.protocol.TField("download", org.apache.thrift.protocol.TType.BOOL, (short) 6); + private static final org.apache.thrift.protocol.TField RECONNECT_FIELD_DESC = new org.apache.thrift.protocol.TField("reconnect", org.apache.thrift.protocol.TType.BOOL, (short) 7); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new ServerStatusStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ServerStatusTupleSchemeFactory()); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // PAUSE - return PAUSE; - case 2: // ACTIVE - return ACTIVE; - case 3: // QUEUE - return QUEUE; - case 4: // TOTAL - return TOTAL; - case 5: // SPEED - return SPEED; - case 6: // DOWNLOAD - return DOWNLOAD; - case 7: // RECONNECT - return RECONNECT; - default: - return null; - } + public boolean pause; // required + public short active; // required + public short queue; // required + public short total; // required + public long speed; // required + public boolean download; // required + public boolean reconnect; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeInt(pause ? 1 : 0); + out.writeInt(new Short(active).intValue()); + out.writeInt(new Short(queue).intValue()); + out.writeInt(new Short(total).intValue()); + out.writeLong(speed); + out.writeInt(download ? 1 : 0); + out.writeInt(reconnect ? 1 : 0); } - /** - * 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; + @Override + public int describeContents() { + return 0; + } + + public ServerStatus(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.pause = (in.readInt() == 1); + this.active = (short) in.readInt(); + this.queue = (short) in.readInt(); + this.total = (short) in.readInt(); + this.speed = in.readLong(); + this.download = (in.readInt() == 1); + this.reconnect = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<ServerStatus> CREATOR = new android.os.Parcelable.Creator<ServerStatus>() { + @Override + public ServerStatus[] newArray(int size) { + return new ServerStatus[size]; + } + + @Override + public ServerStatus createFromParcel(android.os.Parcel in) { + return new ServerStatus(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PAUSE((short) 1, "pause"), + ACTIVE((short) 2, "active"), + QUEUE((short) 3, "queue"), + TOTAL((short) 4, "total"), + SPEED((short) 5, "speed"), + DOWNLOAD((short) 6, "download"), + RECONNECT((short) 7, "reconnect"); + + 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: // PAUSE + return PAUSE; + case 2: // ACTIVE + return ACTIVE; + case 3: // QUEUE + return QUEUE; + case 4: // TOTAL + return TOTAL; + case 5: // SPEED + return SPEED; + case 6: // DOWNLOAD + return DOWNLOAD; + case 7: // RECONNECT + return RECONNECT; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PAUSE_ISSET_ID = 0; + private static final int __ACTIVE_ISSET_ID = 1; + private static final int __QUEUE_ISSET_ID = 2; + private static final int __TOTAL_ISSET_ID = 3; + private static final int __SPEED_ISSET_ID = 4; + private static final int __DOWNLOAD_ISSET_ID = 5; + private static final int __RECONNECT_ISSET_ID = 6; + private byte __isset_bitfield = 0; + 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.PAUSE, new org.apache.thrift.meta_data.FieldMetaData("pause", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.ACTIVE, new org.apache.thrift.meta_data.FieldMetaData("active", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.QUEUE, new org.apache.thrift.meta_data.FieldMetaData("queue", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.TOTAL, new org.apache.thrift.meta_data.FieldMetaData("total", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); + tmpMap.put(_Fields.SPEED, new org.apache.thrift.meta_data.FieldMetaData("speed", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); + tmpMap.put(_Fields.DOWNLOAD, new org.apache.thrift.meta_data.FieldMetaData("download", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + tmpMap.put(_Fields.RECONNECT, new org.apache.thrift.meta_data.FieldMetaData("reconnect", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServerStatus.class, metaDataMap); + } + + public ServerStatus() { + } + + public ServerStatus( + boolean pause, + short active, + short queue, + short total, + long speed, + boolean download, + boolean reconnect) { + this(); + this.pause = pause; + setPauseIsSet(true); + this.active = active; + setActiveIsSet(true); + this.queue = queue; + setQueueIsSet(true); + this.total = total; + setTotalIsSet(true); + this.speed = speed; + setSpeedIsSet(true); + this.download = download; + setDownloadIsSet(true); + this.reconnect = reconnect; + setReconnectIsSet(true); } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __PAUSE_ISSET_ID = 0; - private static final int __ACTIVE_ISSET_ID = 1; - private static final int __QUEUE_ISSET_ID = 2; - private static final int __TOTAL_ISSET_ID = 3; - private static final int __SPEED_ISSET_ID = 4; - private static final int __DOWNLOAD_ISSET_ID = 5; - private static final int __RECONNECT_ISSET_ID = 6; - private BitSet __isset_bit_vector = new BitSet(7); - 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.PAUSE, new org.apache.thrift.meta_data.FieldMetaData("pause", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.ACTIVE, new org.apache.thrift.meta_data.FieldMetaData("active", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.QUEUE, new org.apache.thrift.meta_data.FieldMetaData("queue", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.TOTAL, new org.apache.thrift.meta_data.FieldMetaData("total", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16))); - tmpMap.put(_Fields.SPEED, new org.apache.thrift.meta_data.FieldMetaData("speed", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64))); - tmpMap.put(_Fields.DOWNLOAD, new org.apache.thrift.meta_data.FieldMetaData("download", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - tmpMap.put(_Fields.RECONNECT, new org.apache.thrift.meta_data.FieldMetaData("reconnect", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServerStatus.class, metaDataMap); - } - - public ServerStatus() { - } - - public ServerStatus( - boolean pause, - short active, - short queue, - short total, - long speed, - boolean download, - boolean reconnect) - { - this(); - this.pause = pause; - setPauseIsSet(true); - this.active = active; - setActiveIsSet(true); - this.queue = queue; - setQueueIsSet(true); - this.total = total; - setTotalIsSet(true); - this.speed = speed; - setSpeedIsSet(true); - this.download = download; - setDownloadIsSet(true); - this.reconnect = reconnect; - setReconnectIsSet(true); - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public ServerStatus(ServerStatus other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - this.pause = other.pause; - this.active = other.active; - this.queue = other.queue; - this.total = other.total; - this.speed = other.speed; - this.download = other.download; - this.reconnect = other.reconnect; - } - - public ServerStatus deepCopy() { - return new ServerStatus(this); - } - - @Override - public void clear() { - setPauseIsSet(false); - this.pause = false; - setActiveIsSet(false); - this.active = 0; - setQueueIsSet(false); - this.queue = 0; - setTotalIsSet(false); - this.total = 0; - setSpeedIsSet(false); - this.speed = 0; - setDownloadIsSet(false); - this.download = false; - setReconnectIsSet(false); - this.reconnect = false; - } - - public boolean isPause() { - return this.pause; - } - - public ServerStatus setPause(boolean pause) { - this.pause = pause; - setPauseIsSet(true); - return this; - } - - public void unsetPause() { - __isset_bit_vector.clear(__PAUSE_ISSET_ID); - } - - /** Returns true if field pause is set (has been assigned a value) and false otherwise */ - public boolean isSetPause() { - return __isset_bit_vector.get(__PAUSE_ISSET_ID); - } - - public void setPauseIsSet(boolean value) { - __isset_bit_vector.set(__PAUSE_ISSET_ID, value); - } - - public short getActive() { - return this.active; - } - - public ServerStatus setActive(short active) { - this.active = active; - setActiveIsSet(true); - return this; - } - - public void unsetActive() { - __isset_bit_vector.clear(__ACTIVE_ISSET_ID); - } - - /** Returns true if field active is set (has been assigned a value) and false otherwise */ - public boolean isSetActive() { - return __isset_bit_vector.get(__ACTIVE_ISSET_ID); - } - - public void setActiveIsSet(boolean value) { - __isset_bit_vector.set(__ACTIVE_ISSET_ID, value); - } - - public short getQueue() { - return this.queue; - } - - public ServerStatus setQueue(short queue) { - this.queue = queue; - setQueueIsSet(true); - return this; - } - - public void unsetQueue() { - __isset_bit_vector.clear(__QUEUE_ISSET_ID); - } - - /** Returns true if field queue is set (has been assigned a value) and false otherwise */ - public boolean isSetQueue() { - return __isset_bit_vector.get(__QUEUE_ISSET_ID); - } - - public void setQueueIsSet(boolean value) { - __isset_bit_vector.set(__QUEUE_ISSET_ID, value); - } - - public short getTotal() { - return this.total; - } - - public ServerStatus setTotal(short total) { - this.total = total; - setTotalIsSet(true); - return this; - } - - public void unsetTotal() { - __isset_bit_vector.clear(__TOTAL_ISSET_ID); - } - - /** Returns true if field total is set (has been assigned a value) and false otherwise */ - public boolean isSetTotal() { - return __isset_bit_vector.get(__TOTAL_ISSET_ID); - } - - public void setTotalIsSet(boolean value) { - __isset_bit_vector.set(__TOTAL_ISSET_ID, value); - } - - public long getSpeed() { - return this.speed; - } - - public ServerStatus setSpeed(long speed) { - this.speed = speed; - setSpeedIsSet(true); - return this; - } - - public void unsetSpeed() { - __isset_bit_vector.clear(__SPEED_ISSET_ID); - } - - /** Returns true if field speed is set (has been assigned a value) and false otherwise */ - public boolean isSetSpeed() { - return __isset_bit_vector.get(__SPEED_ISSET_ID); - } - - public void setSpeedIsSet(boolean value) { - __isset_bit_vector.set(__SPEED_ISSET_ID, value); - } - - public boolean isDownload() { - return this.download; - } - - public ServerStatus setDownload(boolean download) { - this.download = download; - setDownloadIsSet(true); - return this; - } - - public void unsetDownload() { - __isset_bit_vector.clear(__DOWNLOAD_ISSET_ID); - } - - /** Returns true if field download is set (has been assigned a value) and false otherwise */ - public boolean isSetDownload() { - return __isset_bit_vector.get(__DOWNLOAD_ISSET_ID); - } - - public void setDownloadIsSet(boolean value) { - __isset_bit_vector.set(__DOWNLOAD_ISSET_ID, value); - } - - public boolean isReconnect() { - return this.reconnect; - } - - public ServerStatus setReconnect(boolean reconnect) { - this.reconnect = reconnect; - setReconnectIsSet(true); - return this; - } - - public void unsetReconnect() { - __isset_bit_vector.clear(__RECONNECT_ISSET_ID); - } - - /** Returns true if field reconnect is set (has been assigned a value) and false otherwise */ - public boolean isSetReconnect() { - return __isset_bit_vector.get(__RECONNECT_ISSET_ID); - } - - public void setReconnectIsSet(boolean value) { - __isset_bit_vector.set(__RECONNECT_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PAUSE: - if (value == null) { - unsetPause(); - } else { - setPause((Boolean)value); - } - break; - - case ACTIVE: - if (value == null) { - unsetActive(); - } else { - setActive((Short)value); - } - break; - - case QUEUE: - if (value == null) { - unsetQueue(); - } else { - setQueue((Short)value); - } - break; - - case TOTAL: - if (value == null) { - unsetTotal(); - } else { - setTotal((Short)value); - } - break; - - case SPEED: - if (value == null) { - unsetSpeed(); - } else { - setSpeed((Long)value); - } - break; - - case DOWNLOAD: - if (value == null) { - unsetDownload(); - } else { - setDownload((Boolean)value); - } - break; - - case RECONNECT: - if (value == null) { - unsetReconnect(); - } else { - setReconnect((Boolean)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PAUSE: - return Boolean.valueOf(isPause()); - - case ACTIVE: - return Short.valueOf(getActive()); - - case QUEUE: - return Short.valueOf(getQueue()); - - case TOTAL: - return Short.valueOf(getTotal()); - - case SPEED: - return Long.valueOf(getSpeed()); - - case DOWNLOAD: - return Boolean.valueOf(isDownload()); - - case RECONNECT: - return Boolean.valueOf(isReconnect()); - - } - 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 PAUSE: - return isSetPause(); - case ACTIVE: - return isSetActive(); - case QUEUE: - return isSetQueue(); - case TOTAL: - return isSetTotal(); - case SPEED: - return isSetSpeed(); - case DOWNLOAD: - return isSetDownload(); - case RECONNECT: - return isSetReconnect(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ServerStatus) - return this.equals((ServerStatus)that); - return false; - } - - public boolean equals(ServerStatus that) { - if (that == null) - return false; - - boolean this_present_pause = true; - boolean that_present_pause = true; - if (this_present_pause || that_present_pause) { - if (!(this_present_pause && that_present_pause)) - return false; - if (this.pause != that.pause) - return false; + public ServerStatus(ServerStatus other) { + __isset_bitfield = other.__isset_bitfield; + this.pause = other.pause; + this.active = other.active; + this.queue = other.queue; + this.total = other.total; + this.speed = other.speed; + this.download = other.download; + this.reconnect = other.reconnect; } - boolean this_present_active = true; - boolean that_present_active = true; - if (this_present_active || that_present_active) { - if (!(this_present_active && that_present_active)) - return false; - if (this.active != that.active) - return false; + public ServerStatus deepCopy() { + return new ServerStatus(this); } - boolean this_present_queue = true; - boolean that_present_queue = true; - if (this_present_queue || that_present_queue) { - if (!(this_present_queue && that_present_queue)) - return false; - if (this.queue != that.queue) - return false; + @Override + public void clear() { + setPauseIsSet(false); + this.pause = false; + setActiveIsSet(false); + this.active = 0; + setQueueIsSet(false); + this.queue = 0; + setTotalIsSet(false); + this.total = 0; + setSpeedIsSet(false); + this.speed = 0; + setDownloadIsSet(false); + this.download = false; + setReconnectIsSet(false); + this.reconnect = false; } - boolean this_present_total = true; - boolean that_present_total = true; - if (this_present_total || that_present_total) { - if (!(this_present_total && that_present_total)) - return false; - if (this.total != that.total) - return false; + public boolean isPause() { + return this.pause; } - boolean this_present_speed = true; - boolean that_present_speed = true; - if (this_present_speed || that_present_speed) { - if (!(this_present_speed && that_present_speed)) - return false; - if (this.speed != that.speed) - return false; + public ServerStatus setPause(boolean pause) { + this.pause = pause; + setPauseIsSet(true); + return this; } - boolean this_present_download = true; - boolean that_present_download = true; - if (this_present_download || that_present_download) { - if (!(this_present_download && that_present_download)) - return false; - if (this.download != that.download) - return false; + public void unsetPause() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PAUSE_ISSET_ID); } - boolean this_present_reconnect = true; - boolean that_present_reconnect = true; - if (this_present_reconnect || that_present_reconnect) { - if (!(this_present_reconnect && that_present_reconnect)) - return false; - if (this.reconnect != that.reconnect) + /** Returns true if field pause is set (has been assigned a value) and false otherwise */ + public boolean isSetPause() { + return EncodingUtils.testBit(__isset_bitfield, __PAUSE_ISSET_ID); + } + + public void setPauseIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PAUSE_ISSET_ID, value); + } + + public short getActive() { + return this.active; + } + + public ServerStatus setActive(short active) { + this.active = active; + setActiveIsSet(true); + return this; + } + + public void unsetActive() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ACTIVE_ISSET_ID); + } + + /** Returns true if field active is set (has been assigned a value) and false otherwise */ + public boolean isSetActive() { + return EncodingUtils.testBit(__isset_bitfield, __ACTIVE_ISSET_ID); + } + + public void setActiveIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ACTIVE_ISSET_ID, value); + } + + public short getQueue() { + return this.queue; + } + + public ServerStatus setQueue(short queue) { + this.queue = queue; + setQueueIsSet(true); + return this; + } + + public void unsetQueue() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __QUEUE_ISSET_ID); + } + + /** Returns true if field queue is set (has been assigned a value) and false otherwise */ + public boolean isSetQueue() { + return EncodingUtils.testBit(__isset_bitfield, __QUEUE_ISSET_ID); + } + + public void setQueueIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __QUEUE_ISSET_ID, value); + } + + public short getTotal() { + return this.total; + } + + public ServerStatus setTotal(short total) { + this.total = total; + setTotalIsSet(true); + return this; + } + + public void unsetTotal() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __TOTAL_ISSET_ID); + } + + /** Returns true if field total is set (has been assigned a value) and false otherwise */ + public boolean isSetTotal() { + return EncodingUtils.testBit(__isset_bitfield, __TOTAL_ISSET_ID); + } + + public void setTotalIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __TOTAL_ISSET_ID, value); + } + + public long getSpeed() { + return this.speed; + } + + public ServerStatus setSpeed(long speed) { + this.speed = speed; + setSpeedIsSet(true); + return this; + } + + public void unsetSpeed() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __SPEED_ISSET_ID); + } + + /** Returns true if field speed is set (has been assigned a value) and false otherwise */ + public boolean isSetSpeed() { + return EncodingUtils.testBit(__isset_bitfield, __SPEED_ISSET_ID); + } + + public void setSpeedIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __SPEED_ISSET_ID, value); + } + + public boolean isDownload() { + return this.download; + } + + public ServerStatus setDownload(boolean download) { + this.download = download; + setDownloadIsSet(true); + return this; + } + + public void unsetDownload() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DOWNLOAD_ISSET_ID); + } + + /** Returns true if field download is set (has been assigned a value) and false otherwise */ + public boolean isSetDownload() { + return EncodingUtils.testBit(__isset_bitfield, __DOWNLOAD_ISSET_ID); + } + + public void setDownloadIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DOWNLOAD_ISSET_ID, value); + } + + public boolean isReconnect() { + return this.reconnect; + } + + public ServerStatus setReconnect(boolean reconnect) { + this.reconnect = reconnect; + setReconnectIsSet(true); + return this; + } + + public void unsetReconnect() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __RECONNECT_ISSET_ID); + } + + /** Returns true if field reconnect is set (has been assigned a value) and false otherwise */ + public boolean isSetReconnect() { + return EncodingUtils.testBit(__isset_bitfield, __RECONNECT_ISSET_ID); + } + + public void setReconnectIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __RECONNECT_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PAUSE: + if (value == null) { + unsetPause(); + } else { + setPause((Boolean) value); + } + break; + + case ACTIVE: + if (value == null) { + unsetActive(); + } else { + setActive((Short) value); + } + break; + + case QUEUE: + if (value == null) { + unsetQueue(); + } else { + setQueue((Short) value); + } + break; + + case TOTAL: + if (value == null) { + unsetTotal(); + } else { + setTotal((Short) value); + } + break; + + case SPEED: + if (value == null) { + unsetSpeed(); + } else { + setSpeed((Long) value); + } + break; + + case DOWNLOAD: + if (value == null) { + unsetDownload(); + } else { + setDownload((Boolean) value); + } + break; + + case RECONNECT: + if (value == null) { + unsetReconnect(); + } else { + setReconnect((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PAUSE: + return isPause(); + + case ACTIVE: + return getActive(); + + case QUEUE: + return getQueue(); + + case TOTAL: + return getTotal(); + + case SPEED: + return getSpeed(); + + case DOWNLOAD: + return isDownload(); + + case RECONNECT: + return isReconnect(); + + } + 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 PAUSE: + return isSetPause(); + case ACTIVE: + return isSetActive(); + case QUEUE: + return isSetQueue(); + case TOTAL: + return isSetTotal(); + case SPEED: + return isSetSpeed(); + case DOWNLOAD: + return isSetDownload(); + case RECONNECT: + return isSetReconnect(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ServerStatus) + return this.equals((ServerStatus) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(ServerStatus other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - ServerStatus typedOther = (ServerStatus)other; - - lastComparison = Boolean.valueOf(isSetPause()).compareTo(typedOther.isSetPause()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPause()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pause, typedOther.pause); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetActive()).compareTo(typedOther.isSetActive()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetActive()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.active, typedOther.active); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetQueue()).compareTo(typedOther.isSetQueue()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetQueue()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queue, typedOther.queue); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetTotal()).compareTo(typedOther.isSetTotal()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTotal()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total, typedOther.total); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetSpeed()).compareTo(typedOther.isSetSpeed()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetSpeed()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.speed, typedOther.speed); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetDownload()).compareTo(typedOther.isSetDownload()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetDownload()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.download, typedOther.download); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetReconnect()).compareTo(typedOther.isSetReconnect()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetReconnect()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reconnect, typedOther.reconnect); - 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("ServerStatus("); - boolean first = true; - - sb.append("pause:"); - sb.append(this.pause); - first = false; - if (!first) sb.append(", "); - sb.append("active:"); - sb.append(this.active); - first = false; - if (!first) sb.append(", "); - sb.append("queue:"); - sb.append(this.queue); - first = false; - if (!first) sb.append(", "); - sb.append("total:"); - sb.append(this.total); - first = false; - if (!first) sb.append(", "); - sb.append("speed:"); - sb.append(this.speed); - first = false; - if (!first) sb.append(", "); - sb.append("download:"); - sb.append(this.download); - first = false; - if (!first) sb.append(", "); - sb.append("reconnect:"); - sb.append(this.reconnect); - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class ServerStatusStandardSchemeFactory implements SchemeFactory { - public ServerStatusStandardScheme getScheme() { - return new ServerStatusStandardScheme(); - } - } - - private static class ServerStatusStandardScheme extends StandardScheme<ServerStatus> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ServerStatus 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: // PAUSE - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.pause = iprot.readBool(); - struct.setPauseIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + public boolean equals(ServerStatus that) { + if (that == null) + return false; + + boolean this_present_pause = true; + boolean that_present_pause = true; + if (this_present_pause || that_present_pause) { + if (!(this_present_pause && that_present_pause)) + return false; + if (this.pause != that.pause) + return false; + } + + boolean this_present_active = true; + boolean that_present_active = true; + if (this_present_active || that_present_active) { + if (!(this_present_active && that_present_active)) + return false; + if (this.active != that.active) + return false; + } + + boolean this_present_queue = true; + boolean that_present_queue = true; + if (this_present_queue || that_present_queue) { + if (!(this_present_queue && that_present_queue)) + return false; + if (this.queue != that.queue) + return false; + } + + boolean this_present_total = true; + boolean that_present_total = true; + if (this_present_total || that_present_total) { + if (!(this_present_total && that_present_total)) + return false; + if (this.total != that.total) + return false; + } + + boolean this_present_speed = true; + boolean that_present_speed = true; + if (this_present_speed || that_present_speed) { + if (!(this_present_speed && that_present_speed)) + return false; + if (this.speed != that.speed) + return false; + } + + boolean this_present_download = true; + boolean that_present_download = true; + if (this_present_download || that_present_download) { + if (!(this_present_download && that_present_download)) + return false; + if (this.download != that.download) + return false; + } + + boolean this_present_reconnect = true; + boolean that_present_reconnect = true; + if (this_present_reconnect || that_present_reconnect) { + if (!(this_present_reconnect && that_present_reconnect)) + return false; + if (this.reconnect != that.reconnect) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_pause = true; + list.add(present_pause); + if (present_pause) + list.add(pause); + + boolean present_active = true; + list.add(present_active); + if (present_active) + list.add(active); + + boolean present_queue = true; + list.add(present_queue); + if (present_queue) + list.add(queue); + + boolean present_total = true; + list.add(present_total); + if (present_total) + list.add(total); + + boolean present_speed = true; + list.add(present_speed); + if (present_speed) + list.add(speed); + + boolean present_download = true; + list.add(present_download); + if (present_download) + list.add(download); + + boolean present_reconnect = true; + list.add(present_reconnect); + if (present_reconnect) + list.add(reconnect); + + return list.hashCode(); + } + + @Override + public int compareTo(ServerStatus other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPause()).compareTo(other.isSetPause()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPause()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.pause, other.pause); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // ACTIVE - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.active = iprot.readI16(); - struct.setActiveIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetActive()).compareTo(other.isSetActive()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetActive()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.active, other.active); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // QUEUE - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.queue = iprot.readI16(); - struct.setQueueIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetQueue()).compareTo(other.isSetQueue()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetQueue()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.queue, other.queue); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // TOTAL - if (schemeField.type == org.apache.thrift.protocol.TType.I16) { - struct.total = iprot.readI16(); - struct.setTotalIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetTotal()).compareTo(other.isSetTotal()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTotal()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.total, other.total); + if (lastComparison != 0) { + return lastComparison; } - break; - case 5: // SPEED - if (schemeField.type == org.apache.thrift.protocol.TType.I64) { - struct.speed = iprot.readI64(); - struct.setSpeedIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetSpeed()).compareTo(other.isSetSpeed()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetSpeed()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.speed, other.speed); + if (lastComparison != 0) { + return lastComparison; } - break; - case 6: // DOWNLOAD - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.download = iprot.readBool(); - struct.setDownloadIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetDownload()).compareTo(other.isSetDownload()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetDownload()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.download, other.download); + if (lastComparison != 0) { + return lastComparison; } - break; - case 7: // RECONNECT - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.reconnect = iprot.readBool(); - struct.setReconnectIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetReconnect()).compareTo(other.isSetReconnect()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetReconnect()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.reconnect, other.reconnect); + if (lastComparison != 0) { + return lastComparison; } - 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, ServerStatus struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - oprot.writeFieldBegin(PAUSE_FIELD_DESC); - oprot.writeBool(struct.pause); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(ACTIVE_FIELD_DESC); - oprot.writeI16(struct.active); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(QUEUE_FIELD_DESC); - oprot.writeI16(struct.queue); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(TOTAL_FIELD_DESC); - oprot.writeI16(struct.total); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(SPEED_FIELD_DESC); - oprot.writeI64(struct.speed); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(DOWNLOAD_FIELD_DESC); - oprot.writeBool(struct.download); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(RECONNECT_FIELD_DESC); - oprot.writeBool(struct.reconnect); - oprot.writeFieldEnd(); - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class ServerStatusTupleSchemeFactory implements SchemeFactory { - public ServerStatusTupleScheme getScheme() { - return new ServerStatusTupleScheme(); - } - } - - private static class ServerStatusTupleScheme extends TupleScheme<ServerStatus> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ServerStatus struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPause()) { - optionals.set(0); - } - if (struct.isSetActive()) { - optionals.set(1); - } - if (struct.isSetQueue()) { - optionals.set(2); - } - if (struct.isSetTotal()) { - optionals.set(3); - } - if (struct.isSetSpeed()) { - optionals.set(4); - } - if (struct.isSetDownload()) { - optionals.set(5); - } - if (struct.isSetReconnect()) { - optionals.set(6); - } - oprot.writeBitSet(optionals, 7); - if (struct.isSetPause()) { - oprot.writeBool(struct.pause); - } - if (struct.isSetActive()) { - oprot.writeI16(struct.active); - } - if (struct.isSetQueue()) { - oprot.writeI16(struct.queue); - } - if (struct.isSetTotal()) { - oprot.writeI16(struct.total); - } - if (struct.isSetSpeed()) { - oprot.writeI64(struct.speed); - } - if (struct.isSetDownload()) { - oprot.writeBool(struct.download); - } - if (struct.isSetReconnect()) { - oprot.writeBool(struct.reconnect); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, ServerStatus struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(7); - if (incoming.get(0)) { - struct.pause = iprot.readBool(); - struct.setPauseIsSet(true); - } - if (incoming.get(1)) { - struct.active = iprot.readI16(); - struct.setActiveIsSet(true); - } - if (incoming.get(2)) { - struct.queue = iprot.readI16(); - struct.setQueueIsSet(true); - } - if (incoming.get(3)) { - struct.total = iprot.readI16(); - struct.setTotalIsSet(true); - } - if (incoming.get(4)) { - struct.speed = iprot.readI64(); - struct.setSpeedIsSet(true); - } - if (incoming.get(5)) { - struct.download = iprot.readBool(); - struct.setDownloadIsSet(true); - } - if (incoming.get(6)) { - struct.reconnect = iprot.readBool(); - struct.setReconnectIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("ServerStatus("); + boolean first = true; + + sb.append("pause:"); + sb.append(this.pause); + first = false; + if (!first) sb.append(", "); + sb.append("active:"); + sb.append(this.active); + first = false; + if (!first) sb.append(", "); + sb.append("queue:"); + sb.append(this.queue); + first = false; + if (!first) sb.append(", "); + sb.append("total:"); + sb.append(this.total); + first = false; + if (!first) sb.append(", "); + sb.append("speed:"); + sb.append(this.speed); + first = false; + if (!first) sb.append(", "); + sb.append("download:"); + sb.append(this.download); + first = false; + if (!first) sb.append(", "); + sb.append("reconnect:"); + sb.append(this.reconnect); + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 ServerStatusStandardSchemeFactory implements SchemeFactory { + public ServerStatusStandardScheme getScheme() { + return new ServerStatusStandardScheme(); + } + } + + private static class ServerStatusStandardScheme extends StandardScheme<ServerStatus> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ServerStatus 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: // PAUSE + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.pause = iprot.readBool(); + struct.setPauseIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // ACTIVE + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.active = iprot.readI16(); + struct.setActiveIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // QUEUE + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.queue = iprot.readI16(); + struct.setQueueIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // TOTAL + if (schemeField.type == org.apache.thrift.protocol.TType.I16) { + struct.total = iprot.readI16(); + struct.setTotalIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // SPEED + if (schemeField.type == org.apache.thrift.protocol.TType.I64) { + struct.speed = iprot.readI64(); + struct.setSpeedIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 6: // DOWNLOAD + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.download = iprot.readBool(); + struct.setDownloadIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 7: // RECONNECT + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.reconnect = iprot.readBool(); + struct.setReconnectIsSet(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, ServerStatus struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + oprot.writeFieldBegin(PAUSE_FIELD_DESC); + oprot.writeBool(struct.pause); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(ACTIVE_FIELD_DESC); + oprot.writeI16(struct.active); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(QUEUE_FIELD_DESC); + oprot.writeI16(struct.queue); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(TOTAL_FIELD_DESC); + oprot.writeI16(struct.total); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(SPEED_FIELD_DESC); + oprot.writeI64(struct.speed); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(DOWNLOAD_FIELD_DESC); + oprot.writeBool(struct.download); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(RECONNECT_FIELD_DESC); + oprot.writeBool(struct.reconnect); + oprot.writeFieldEnd(); + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ServerStatusTupleSchemeFactory implements SchemeFactory { + public ServerStatusTupleScheme getScheme() { + return new ServerStatusTupleScheme(); + } + } + + private static class ServerStatusTupleScheme extends TupleScheme<ServerStatus> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ServerStatus struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPause()) { + optionals.set(0); + } + if (struct.isSetActive()) { + optionals.set(1); + } + if (struct.isSetQueue()) { + optionals.set(2); + } + if (struct.isSetTotal()) { + optionals.set(3); + } + if (struct.isSetSpeed()) { + optionals.set(4); + } + if (struct.isSetDownload()) { + optionals.set(5); + } + if (struct.isSetReconnect()) { + optionals.set(6); + } + oprot.writeBitSet(optionals, 7); + if (struct.isSetPause()) { + oprot.writeBool(struct.pause); + } + if (struct.isSetActive()) { + oprot.writeI16(struct.active); + } + if (struct.isSetQueue()) { + oprot.writeI16(struct.queue); + } + if (struct.isSetTotal()) { + oprot.writeI16(struct.total); + } + if (struct.isSetSpeed()) { + oprot.writeI64(struct.speed); + } + if (struct.isSetDownload()) { + oprot.writeBool(struct.download); + } + if (struct.isSetReconnect()) { + oprot.writeBool(struct.reconnect); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ServerStatus struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(7); + if (incoming.get(0)) { + struct.pause = iprot.readBool(); + struct.setPauseIsSet(true); + } + if (incoming.get(1)) { + struct.active = iprot.readI16(); + struct.setActiveIsSet(true); + } + if (incoming.get(2)) { + struct.queue = iprot.readI16(); + struct.setQueueIsSet(true); + } + if (incoming.get(3)) { + struct.total = iprot.readI16(); + struct.setTotalIsSet(true); + } + if (incoming.get(4)) { + struct.speed = iprot.readI64(); + struct.setSpeedIsSet(true); + } + if (incoming.get(5)) { + struct.download = iprot.readBool(); + struct.setDownloadIsSet(true); + } + if (incoming.get(6)) { + struct.reconnect = iprot.readBool(); + struct.setReconnectIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ServiceCall.java b/app/src/main/java/org/pyload/thrift/ServiceCall.java index ab5d495..29411e2 100644 --- a/app/src/main/java/org/pyload/thrift/ServiceCall.java +++ b/app/src/main/java/org/pyload/thrift/ServiceCall.java @@ -1,737 +1,789 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class ServiceCall implements org.apache.thrift.TBase<ServiceCall, ServiceCall._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceCall"); - - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField ARGUMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("arguments", org.apache.thrift.protocol.TType.LIST, (short)3); - private static final org.apache.thrift.protocol.TField PARSE_ARGUMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("parseArguments", org.apache.thrift.protocol.TType.BOOL, (short)4); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ServiceCallStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ServiceCallTupleSchemeFactory()); - } - - public String plugin; // required - public String func; // required - public List<String> arguments; // required - public boolean parseArguments; // 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 { - PLUGIN((short)1, "plugin"), - FUNC((short)2, "func"), - ARGUMENTS((short)3, "arguments"), - PARSE_ARGUMENTS((short)4, "parseArguments"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ServiceCall implements org.apache.thrift.TBase<ServiceCall, ServiceCall._Fields>, java.io.Serializable, Cloneable, Comparable<ServiceCall>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceCall"); + + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField ARGUMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("arguments", org.apache.thrift.protocol.TType.LIST, (short) 3); + private static final org.apache.thrift.protocol.TField PARSE_ARGUMENTS_FIELD_DESC = new org.apache.thrift.protocol.TField("parseArguments", org.apache.thrift.protocol.TType.BOOL, (short) 4); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new ServiceCallStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ServiceCallTupleSchemeFactory()); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // PLUGIN - return PLUGIN; - case 2: // FUNC - return FUNC; - case 3: // ARGUMENTS - return ARGUMENTS; - case 4: // PARSE_ARGUMENTS - return PARSE_ARGUMENTS; - default: - return null; - } + public String plugin; // required + public String func; // required + public List<String> arguments; // optional + public boolean parseArguments; // optional + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeString(plugin); + out.writeString(func); + out.writeList(arguments); + out.writeInt(parseArguments ? 1 : 0); } - /** - * 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; + @Override + public int describeContents() { + return 0; + } + + public ServiceCall(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.plugin = in.readString(); + this.func = in.readString(); + this.arguments = new ArrayList<String>(); + in.readList(this.arguments, ServiceCall.class.getClassLoader()); + this.parseArguments = (in.readInt() == 1); + } + + public static final android.os.Parcelable.Creator<ServiceCall> CREATOR = new android.os.Parcelable.Creator<ServiceCall>() { + @Override + public ServiceCall[] newArray(int size) { + return new ServiceCall[size]; + } + + @Override + public ServiceCall createFromParcel(android.os.Parcel in) { + return new ServiceCall(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"), + FUNC((short) 2, "func"), + ARGUMENTS((short) 3, "arguments"), + PARSE_ARGUMENTS((short) 4, "parseArguments"); + + 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: // PLUGIN + return PLUGIN; + case 2: // FUNC + return FUNC; + case 3: // ARGUMENTS + return ARGUMENTS; + case 4: // PARSE_ARGUMENTS + return PARSE_ARGUMENTS; + default: + return null; + } + } + + /** + * Find the _Fields constant that matches fieldId, throwing an exception + * if it is not found. + */ + public static _Fields findByThriftIdOrThrow(int fieldId) { + _Fields fields = findByThriftId(fieldId); + if (fields == null) + throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __PARSEARGUMENTS_ISSET_ID = 0; + private byte __isset_bitfield = 0; + private static final _Fields optionals[] = {_Fields.ARGUMENTS, _Fields.PARSE_ARGUMENTS}; + 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.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING, "PluginName"))); + tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ARGUMENTS, new org.apache.thrift.meta_data.FieldMetaData("arguments", 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)))); + tmpMap.put(_Fields.PARSE_ARGUMENTS, new org.apache.thrift.meta_data.FieldMetaData("parseArguments", org.apache.thrift.TFieldRequirementType.OPTIONAL, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceCall.class, metaDataMap); + } + + public ServiceCall() { + } + + public ServiceCall( + String plugin, + String func) { + this(); + this.plugin = plugin; + this.func = func; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __PARSEARGUMENTS_ISSET_ID = 0; - private BitSet __isset_bit_vector = new BitSet(1); - private _Fields optionals[] = {_Fields.ARGUMENTS,_Fields.PARSE_ARGUMENTS}; - 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.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING , "PluginName"))); - tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.ARGUMENTS, new org.apache.thrift.meta_data.FieldMetaData("arguments", 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)))); - tmpMap.put(_Fields.PARSE_ARGUMENTS, new org.apache.thrift.meta_data.FieldMetaData("parseArguments", org.apache.thrift.TFieldRequirementType.OPTIONAL, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceCall.class, metaDataMap); - } - - public ServiceCall() { - } - - public ServiceCall( - String plugin, - String func) - { - this(); - this.plugin = plugin; - this.func = func; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public ServiceCall(ServiceCall other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetFunc()) { - this.func = other.func; - } - if (other.isSetArguments()) { - List<String> __this__arguments = new ArrayList<String>(); - for (String other_element : other.arguments) { - __this__arguments.add(other_element); - } - this.arguments = __this__arguments; - } - this.parseArguments = other.parseArguments; - } - - public ServiceCall deepCopy() { - return new ServiceCall(this); - } - - @Override - public void clear() { - this.plugin = null; - this.func = null; - this.arguments = null; - setParseArgumentsIsSet(false); - this.parseArguments = false; - } - - public String getPlugin() { - return this.plugin; - } - - public ServiceCall setPlugin(String plugin) { - this.plugin = plugin; - return this; - } - - public void unsetPlugin() { - this.plugin = null; - } - - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } - - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } - - public String getFunc() { - return this.func; - } - - public ServiceCall setFunc(String func) { - this.func = func; - return this; - } - - public void unsetFunc() { - this.func = null; - } - - /** Returns true if field func is set (has been assigned a value) and false otherwise */ - public boolean isSetFunc() { - return this.func != null; - } - - public void setFuncIsSet(boolean value) { - if (!value) { - this.func = null; - } - } - - public int getArgumentsSize() { - return (this.arguments == null) ? 0 : this.arguments.size(); - } - - public java.util.Iterator<String> getArgumentsIterator() { - return (this.arguments == null) ? null : this.arguments.iterator(); - } - - public void addToArguments(String elem) { - if (this.arguments == null) { - this.arguments = new ArrayList<String>(); - } - this.arguments.add(elem); - } - - public List<String> getArguments() { - return this.arguments; - } - - public ServiceCall setArguments(List<String> arguments) { - this.arguments = arguments; - return this; - } - - public void unsetArguments() { - this.arguments = null; - } - - /** Returns true if field arguments is set (has been assigned a value) and false otherwise */ - public boolean isSetArguments() { - return this.arguments != null; - } - - public void setArgumentsIsSet(boolean value) { - if (!value) { - this.arguments = null; - } - } - - public boolean isParseArguments() { - return this.parseArguments; - } - - public ServiceCall setParseArguments(boolean parseArguments) { - this.parseArguments = parseArguments; - setParseArgumentsIsSet(true); - return this; - } - - public void unsetParseArguments() { - __isset_bit_vector.clear(__PARSEARGUMENTS_ISSET_ID); - } - - /** Returns true if field parseArguments is set (has been assigned a value) and false otherwise */ - public boolean isSetParseArguments() { - return __isset_bit_vector.get(__PARSEARGUMENTS_ISSET_ID); - } - - public void setParseArgumentsIsSet(boolean value) { - __isset_bit_vector.set(__PARSEARGUMENTS_ISSET_ID, value); - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); - } - break; - - case FUNC: - if (value == null) { - unsetFunc(); - } else { - setFunc((String)value); - } - break; - - case ARGUMENTS: - if (value == null) { - unsetArguments(); - } else { - setArguments((List<String>)value); - } - break; - - case PARSE_ARGUMENTS: - if (value == null) { - unsetParseArguments(); - } else { - setParseArguments((Boolean)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); - - case FUNC: - return getFunc(); - - case ARGUMENTS: - return getArguments(); - - case PARSE_ARGUMENTS: - return Boolean.valueOf(isParseArguments()); - - } - 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 PLUGIN: - return isSetPlugin(); - case FUNC: - return isSetFunc(); - case ARGUMENTS: - return isSetArguments(); - case PARSE_ARGUMENTS: - return isSetParseArguments(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ServiceCall) - return this.equals((ServiceCall)that); - return false; - } - - public boolean equals(ServiceCall that) { - if (that == null) - return false; - - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; + public ServiceCall(ServiceCall other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetFunc()) { + this.func = other.func; + } + if (other.isSetArguments()) { + List<String> __this__arguments = new ArrayList<String>(other.arguments); + this.arguments = __this__arguments; + } + this.parseArguments = other.parseArguments; } - boolean this_present_func = true && this.isSetFunc(); - boolean that_present_func = true && that.isSetFunc(); - if (this_present_func || that_present_func) { - if (!(this_present_func && that_present_func)) - return false; - if (!this.func.equals(that.func)) - return false; + public ServiceCall deepCopy() { + return new ServiceCall(this); } - boolean this_present_arguments = true && this.isSetArguments(); - boolean that_present_arguments = true && that.isSetArguments(); - if (this_present_arguments || that_present_arguments) { - if (!(this_present_arguments && that_present_arguments)) - return false; - if (!this.arguments.equals(that.arguments)) - return false; + @Override + public void clear() { + this.plugin = null; + this.func = null; + this.arguments = null; + setParseArgumentsIsSet(false); + this.parseArguments = false; } - boolean this_present_parseArguments = true && this.isSetParseArguments(); - boolean that_present_parseArguments = true && that.isSetParseArguments(); - if (this_present_parseArguments || that_present_parseArguments) { - if (!(this_present_parseArguments && that_present_parseArguments)) - return false; - if (this.parseArguments != that.parseArguments) + public String getPlugin() { + return this.plugin; + } + + public ServiceCall setPlugin(String plugin) { + this.plugin = plugin; + return this; + } + + public void unsetPlugin() { + this.plugin = null; + } + + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } + + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } + + public String getFunc() { + return this.func; + } + + public ServiceCall setFunc(String func) { + this.func = func; + return this; + } + + public void unsetFunc() { + this.func = null; + } + + /** Returns true if field func is set (has been assigned a value) and false otherwise */ + public boolean isSetFunc() { + return this.func != null; + } + + public void setFuncIsSet(boolean value) { + if (!value) { + this.func = null; + } + } + + public int getArgumentsSize() { + return (this.arguments == null) ? 0 : this.arguments.size(); + } + + public java.util.Iterator<String> getArgumentsIterator() { + return (this.arguments == null) ? null : this.arguments.iterator(); + } + + public void addToArguments(String elem) { + if (this.arguments == null) { + this.arguments = new ArrayList<String>(); + } + this.arguments.add(elem); + } + + public List<String> getArguments() { + return this.arguments; + } + + public ServiceCall setArguments(List<String> arguments) { + this.arguments = arguments; + return this; + } + + public void unsetArguments() { + this.arguments = null; + } + + /** Returns true if field arguments is set (has been assigned a value) and false otherwise */ + public boolean isSetArguments() { + return this.arguments != null; + } + + public void setArgumentsIsSet(boolean value) { + if (!value) { + this.arguments = null; + } + } + + public boolean isParseArguments() { + return this.parseArguments; + } + + public ServiceCall setParseArguments(boolean parseArguments) { + this.parseArguments = parseArguments; + setParseArgumentsIsSet(true); + return this; + } + + public void unsetParseArguments() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PARSEARGUMENTS_ISSET_ID); + } + + /** Returns true if field parseArguments is set (has been assigned a value) and false otherwise */ + public boolean isSetParseArguments() { + return EncodingUtils.testBit(__isset_bitfield, __PARSEARGUMENTS_ISSET_ID); + } + + public void setParseArgumentsIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PARSEARGUMENTS_ISSET_ID, value); + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + case FUNC: + if (value == null) { + unsetFunc(); + } else { + setFunc((String) value); + } + break; + + case ARGUMENTS: + if (value == null) { + unsetArguments(); + } else { + setArguments((List<String>) value); + } + break; + + case PARSE_ARGUMENTS: + if (value == null) { + unsetParseArguments(); + } else { + setParseArguments((Boolean) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); + + case FUNC: + return getFunc(); + + case ARGUMENTS: + return getArguments(); + + case PARSE_ARGUMENTS: + return isParseArguments(); + + } + 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 PLUGIN: + return isSetPlugin(); + case FUNC: + return isSetFunc(); + case ARGUMENTS: + return isSetArguments(); + case PARSE_ARGUMENTS: + return isSetParseArguments(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ServiceCall) + return this.equals((ServiceCall) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(ServiceCall other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - ServiceCall typedOther = (ServiceCall)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFunc()).compareTo(typedOther.isSetFunc()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFunc()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, typedOther.func); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetArguments()).compareTo(typedOther.isSetArguments()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetArguments()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.arguments, typedOther.arguments); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetParseArguments()).compareTo(typedOther.isSetParseArguments()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetParseArguments()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.parseArguments, typedOther.parseArguments); - 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("ServiceCall("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("func:"); - if (this.func == null) { - sb.append("null"); - } else { - sb.append(this.func); - } - first = false; - if (isSetArguments()) { - if (!first) sb.append(", "); - sb.append("arguments:"); - if (this.arguments == null) { - sb.append("null"); - } else { - sb.append(this.arguments); - } - first = false; - } - if (isSetParseArguments()) { - if (!first) sb.append(", "); - sb.append("parseArguments:"); - sb.append(this.parseArguments); - first = false; - } - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class ServiceCallStandardSchemeFactory implements SchemeFactory { - public ServiceCallStandardScheme getScheme() { - return new ServiceCallStandardScheme(); - } - } - - private static class ServiceCallStandardScheme extends StandardScheme<ServiceCall> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceCall 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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); - } - break; - case 2: // FUNC - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.func = iprot.readString(); - struct.setFuncIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + public boolean equals(ServiceCall that) { + if (that == null) + return false; + + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + boolean this_present_func = true && this.isSetFunc(); + boolean that_present_func = true && that.isSetFunc(); + if (this_present_func || that_present_func) { + if (!(this_present_func && that_present_func)) + return false; + if (!this.func.equals(that.func)) + return false; + } + + boolean this_present_arguments = true && this.isSetArguments(); + boolean that_present_arguments = true && that.isSetArguments(); + if (this_present_arguments || that_present_arguments) { + if (!(this_present_arguments && that_present_arguments)) + return false; + if (!this.arguments.equals(that.arguments)) + return false; + } + + boolean this_present_parseArguments = true && this.isSetParseArguments(); + boolean that_present_parseArguments = true && that.isSetParseArguments(); + if (this_present_parseArguments || that_present_parseArguments) { + if (!(this_present_parseArguments && that_present_parseArguments)) + return false; + if (this.parseArguments != that.parseArguments) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); + + boolean present_func = true && (isSetFunc()); + list.add(present_func); + if (present_func) + list.add(func); + + boolean present_arguments = true && (isSetArguments()); + list.add(present_arguments); + if (present_arguments) + list.add(arguments); + + boolean present_parseArguments = true && (isSetParseArguments()); + list.add(present_parseArguments); + if (present_parseArguments) + list.add(parseArguments); + + return list.hashCode(); + } + + @Override + public int compareTo(ServiceCall other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // ARGUMENTS - if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { - { - org.apache.thrift.protocol.TList _list42 = iprot.readListBegin(); - struct.arguments = new ArrayList<String>(_list42.size); - for (int _i43 = 0; _i43 < _list42.size; ++_i43) - { - String _elem44; // required - _elem44 = iprot.readString(); - struct.arguments.add(_elem44); - } - iprot.readListEnd(); - } - struct.setArgumentsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetFunc()).compareTo(other.isSetFunc()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFunc()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, other.func); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // PARSE_ARGUMENTS - if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { - struct.parseArguments = iprot.readBool(); - struct.setParseArgumentsIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetArguments()).compareTo(other.isSetArguments()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetArguments()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.arguments, other.arguments); + if (lastComparison != 0) { + return lastComparison; } - 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, ServiceCall struct) throws org.apache.thrift.TException { - struct.validate(); - - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.func != null) { - oprot.writeFieldBegin(FUNC_FIELD_DESC); - oprot.writeString(struct.func); - oprot.writeFieldEnd(); - } - if (struct.arguments != null) { - if (struct.isSetArguments()) { - oprot.writeFieldBegin(ARGUMENTS_FIELD_DESC); - { - oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.arguments.size())); - for (String _iter45 : struct.arguments) - { - oprot.writeString(_iter45); + } + lastComparison = Boolean.valueOf(isSetParseArguments()).compareTo(other.isSetParseArguments()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetParseArguments()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.parseArguments, other.parseArguments); + if (lastComparison != 0) { + return lastComparison; } - oprot.writeListEnd(); - } - oprot.writeFieldEnd(); } - } - if (struct.isSetParseArguments()) { - oprot.writeFieldBegin(PARSE_ARGUMENTS_FIELD_DESC); - oprot.writeBool(struct.parseArguments); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); + return 0; } - } + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - private static class ServiceCallTupleSchemeFactory implements SchemeFactory { - public ServiceCallTupleScheme getScheme() { - return new ServiceCallTupleScheme(); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); } - } - private static class ServiceCallTupleScheme extends TupleScheme<ServiceCall> { + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ServiceCall struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); - } - if (struct.isSetFunc()) { - optionals.set(1); - } - if (struct.isSetArguments()) { - optionals.set(2); - } - if (struct.isSetParseArguments()) { - optionals.set(3); - } - oprot.writeBitSet(optionals, 4); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetFunc()) { - oprot.writeString(struct.func); - } - if (struct.isSetArguments()) { - { - oprot.writeI32(struct.arguments.size()); - for (String _iter46 : struct.arguments) - { - oprot.writeString(_iter46); - } - } - } - if (struct.isSetParseArguments()) { - oprot.writeBool(struct.parseArguments); - } + public String toString() { + StringBuilder sb = new StringBuilder("ServiceCall("); + boolean first = true; + + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("func:"); + if (this.func == null) { + sb.append("null"); + } else { + sb.append(this.func); + } + first = false; + if (isSetArguments()) { + if (!first) sb.append(", "); + sb.append("arguments:"); + if (this.arguments == null) { + sb.append("null"); + } else { + sb.append(this.arguments); + } + first = false; + } + if (isSetParseArguments()) { + if (!first) sb.append(", "); + sb.append("parseArguments:"); + sb.append(this.parseArguments); + first = false; + } + sb.append(")"); + return sb.toString(); } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, ServiceCall struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(4); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(1)) { - struct.func = iprot.readString(); - struct.setFuncIsSet(true); - } - if (incoming.get(2)) { - { - org.apache.thrift.protocol.TList _list47 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); - struct.arguments = new ArrayList<String>(_list47.size); - for (int _i48 = 0; _i48 < _list47.size; ++_i48) - { - String _elem49; // required - _elem49 = iprot.readString(); - struct.arguments.add(_elem49); - } - } - struct.setArgumentsIsSet(true); - } - if (incoming.get(3)) { - struct.parseArguments = iprot.readBool(); - struct.setParseArgumentsIsSet(true); - } - } - } + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 ServiceCallStandardSchemeFactory implements SchemeFactory { + public ServiceCallStandardScheme getScheme() { + return new ServiceCallStandardScheme(); + } + } + + private static class ServiceCallStandardScheme extends StandardScheme<ServiceCall> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceCall 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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // FUNC + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.func = iprot.readString(); + struct.setFuncIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // ARGUMENTS + if (schemeField.type == org.apache.thrift.protocol.TType.LIST) { + { + org.apache.thrift.protocol.TList _list66 = iprot.readListBegin(); + struct.arguments = new ArrayList<String>(_list66.size); + String _elem67; + for (int _i68 = 0; _i68 < _list66.size; ++_i68) { + _elem67 = iprot.readString(); + struct.arguments.add(_elem67); + } + iprot.readListEnd(); + } + struct.setArgumentsIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // PARSE_ARGUMENTS + if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) { + struct.parseArguments = iprot.readBool(); + struct.setParseArgumentsIsSet(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, ServiceCall struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.func != null) { + oprot.writeFieldBegin(FUNC_FIELD_DESC); + oprot.writeString(struct.func); + oprot.writeFieldEnd(); + } + if (struct.arguments != null) { + if (struct.isSetArguments()) { + oprot.writeFieldBegin(ARGUMENTS_FIELD_DESC); + { + oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.arguments.size())); + for (String _iter69 : struct.arguments) { + oprot.writeString(_iter69); + } + oprot.writeListEnd(); + } + oprot.writeFieldEnd(); + } + } + if (struct.isSetParseArguments()) { + oprot.writeFieldBegin(PARSE_ARGUMENTS_FIELD_DESC); + oprot.writeBool(struct.parseArguments); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ServiceCallTupleSchemeFactory implements SchemeFactory { + public ServiceCallTupleScheme getScheme() { + return new ServiceCallTupleScheme(); + } + } + + private static class ServiceCallTupleScheme extends TupleScheme<ServiceCall> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ServiceCall struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + if (struct.isSetFunc()) { + optionals.set(1); + } + if (struct.isSetArguments()) { + optionals.set(2); + } + if (struct.isSetParseArguments()) { + optionals.set(3); + } + oprot.writeBitSet(optionals, 4); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetFunc()) { + oprot.writeString(struct.func); + } + if (struct.isSetArguments()) { + { + oprot.writeI32(struct.arguments.size()); + for (String _iter70 : struct.arguments) { + oprot.writeString(_iter70); + } + } + } + if (struct.isSetParseArguments()) { + oprot.writeBool(struct.parseArguments); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ServiceCall struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(4); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(1)) { + struct.func = iprot.readString(); + struct.setFuncIsSet(true); + } + if (incoming.get(2)) { + { + org.apache.thrift.protocol.TList _list71 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32()); + struct.arguments = new ArrayList<String>(_list71.size); + String _elem72; + for (int _i73 = 0; _i73 < _list71.size; ++_i73) { + _elem72 = iprot.readString(); + struct.arguments.add(_elem72); + } + } + struct.setArgumentsIsSet(true); + } + if (incoming.get(3)) { + struct.parseArguments = iprot.readBool(); + struct.setParseArgumentsIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ServiceDoesNotExists.java b/app/src/main/java/org/pyload/thrift/ServiceDoesNotExists.java index 065753f..847f983 100644 --- a/app/src/main/java/org/pyload/thrift/ServiceDoesNotExists.java +++ b/app/src/main/java/org/pyload/thrift/ServiceDoesNotExists.java @@ -1,482 +1,521 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.TException; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ServiceDoesNotExists extends TException implements org.apache.thrift.TBase<ServiceDoesNotExists, ServiceDoesNotExists._Fields>, java.io.Serializable, Cloneable, Comparable<ServiceDoesNotExists>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceDoesNotExists"); + + private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short) 1); + private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short) 2); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); + + static { + schemes.put(StandardScheme.class, new ServiceDoesNotExistsStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ServiceDoesNotExistsTupleSchemeFactory()); + } + + public String plugin; // required + public String func; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(plugin); + out.writeString(func); + } + + @Override + public int describeContents() { + return 0; + } + + public ServiceDoesNotExists(android.os.Parcel in) { + this.plugin = in.readString(); + this.func = in.readString(); + } + + public static final android.os.Parcelable.Creator<ServiceDoesNotExists> CREATOR = new android.os.Parcelable.Creator<ServiceDoesNotExists>() { + @Override + public ServiceDoesNotExists[] newArray(int size) { + return new ServiceDoesNotExists[size]; + } + + @Override + public ServiceDoesNotExists createFromParcel(android.os.Parcel in) { + return new ServiceDoesNotExists(in); + } + }; + + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + PLUGIN((short) 1, "plugin"), + FUNC((short) 2, "func"); -public class ServiceDoesNotExists extends Exception implements org.apache.thrift.TBase<ServiceDoesNotExists, ServiceDoesNotExists._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceDoesNotExists"); + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - private static final org.apache.thrift.protocol.TField PLUGIN_FIELD_DESC = new org.apache.thrift.protocol.TField("plugin", org.apache.thrift.protocol.TType.STRING, (short)1); - private static final org.apache.thrift.protocol.TField FUNC_FIELD_DESC = new org.apache.thrift.protocol.TField("func", org.apache.thrift.protocol.TType.STRING, (short)2); + 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: // PLUGIN + return PLUGIN; + case 2: // FUNC + return FUNC; + 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 static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ServiceDoesNotExistsStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ServiceDoesNotExistsTupleSchemeFactory()); - } + private final short _thriftId; + private final String _fieldName; - public String plugin; // required - public String func; // required + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - PLUGIN((short)1, "plugin"), - FUNC((short)2, "func"); + public String getFieldName() { + return _fieldName; + } + } - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceDoesNotExists.class, metaDataMap); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // PLUGIN - return PLUGIN; - case 2: // FUNC - return FUNC; - default: - return null; - } + public ServiceDoesNotExists() { } - /** - * 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; + public ServiceDoesNotExists( + String plugin, + String func) { + this(); + this.plugin = plugin; + this.func = func; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); + public ServiceDoesNotExists(ServiceDoesNotExists other) { + if (other.isSetPlugin()) { + this.plugin = other.plugin; + } + if (other.isSetFunc()) { + this.func = other.func; + } } - private final short _thriftId; - private final String _fieldName; + public ServiceDoesNotExists deepCopy() { + return new ServiceDoesNotExists(this); + } - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; + @Override + public void clear() { + this.plugin = null; + this.func = null; } - - public short getThriftFieldId() { - return _thriftId; + + public String getPlugin() { + return this.plugin; } - public String getFieldName() { - return _fieldName; + public ServiceDoesNotExists setPlugin(String plugin) { + this.plugin = plugin; + return this; } - } - - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.PLUGIN, new org.apache.thrift.meta_data.FieldMetaData("plugin", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.FUNC, new org.apache.thrift.meta_data.FieldMetaData("func", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceDoesNotExists.class, metaDataMap); - } - - public ServiceDoesNotExists() { - } - - public ServiceDoesNotExists( - String plugin, - String func) - { - this(); - this.plugin = plugin; - this.func = func; - } - /** - * Performs a deep copy on <i>other</i>. - */ - public ServiceDoesNotExists(ServiceDoesNotExists other) { - if (other.isSetPlugin()) { - this.plugin = other.plugin; - } - if (other.isSetFunc()) { - this.func = other.func; + public void unsetPlugin() { + this.plugin = null; } - } - public ServiceDoesNotExists deepCopy() { - return new ServiceDoesNotExists(this); - } + /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ + public boolean isSetPlugin() { + return this.plugin != null; + } - @Override - public void clear() { - this.plugin = null; - this.func = null; - } + public void setPluginIsSet(boolean value) { + if (!value) { + this.plugin = null; + } + } - public String getPlugin() { - return this.plugin; - } - - public ServiceDoesNotExists setPlugin(String plugin) { - this.plugin = plugin; - return this; - } - - public void unsetPlugin() { - this.plugin = null; - } - - /** Returns true if field plugin is set (has been assigned a value) and false otherwise */ - public boolean isSetPlugin() { - return this.plugin != null; - } - - public void setPluginIsSet(boolean value) { - if (!value) { - this.plugin = null; - } - } - - public String getFunc() { - return this.func; - } - - public ServiceDoesNotExists setFunc(String func) { - this.func = func; - return this; - } - - public void unsetFunc() { - this.func = null; - } - - /** Returns true if field func is set (has been assigned a value) and false otherwise */ - public boolean isSetFunc() { - return this.func != null; - } - - public void setFuncIsSet(boolean value) { - if (!value) { - this.func = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case PLUGIN: - if (value == null) { - unsetPlugin(); - } else { - setPlugin((String)value); - } - break; - - case FUNC: - if (value == null) { - unsetFunc(); - } else { - setFunc((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case PLUGIN: - return getPlugin(); - - case FUNC: - return getFunc(); - - } - 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 PLUGIN: - return isSetPlugin(); - case FUNC: - return isSetFunc(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ServiceDoesNotExists) - return this.equals((ServiceDoesNotExists)that); - return false; - } - - public boolean equals(ServiceDoesNotExists that) { - if (that == null) - return false; - - boolean this_present_plugin = true && this.isSetPlugin(); - boolean that_present_plugin = true && that.isSetPlugin(); - if (this_present_plugin || that_present_plugin) { - if (!(this_present_plugin && that_present_plugin)) - return false; - if (!this.plugin.equals(that.plugin)) - return false; + public String getFunc() { + return this.func; } - boolean this_present_func = true && this.isSetFunc(); - boolean that_present_func = true && that.isSetFunc(); - if (this_present_func || that_present_func) { - if (!(this_present_func && that_present_func)) - return false; - if (!this.func.equals(that.func)) + public ServiceDoesNotExists setFunc(String func) { + this.func = func; + return this; + } + + public void unsetFunc() { + this.func = null; + } + + /** Returns true if field func is set (has been assigned a value) and false otherwise */ + public boolean isSetFunc() { + return this.func != null; + } + + public void setFuncIsSet(boolean value) { + if (!value) { + this.func = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case PLUGIN: + if (value == null) { + unsetPlugin(); + } else { + setPlugin((String) value); + } + break; + + case FUNC: + if (value == null) { + unsetFunc(); + } else { + setFunc((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case PLUGIN: + return getPlugin(); + + case FUNC: + return getFunc(); + + } + 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 PLUGIN: + return isSetPlugin(); + case FUNC: + return isSetFunc(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ServiceDoesNotExists) + return this.equals((ServiceDoesNotExists) that); return false; } - return true; - } + public boolean equals(ServiceDoesNotExists that) { + if (that == null) + return false; + + boolean this_present_plugin = true && this.isSetPlugin(); + boolean that_present_plugin = true && that.isSetPlugin(); + if (this_present_plugin || that_present_plugin) { + if (!(this_present_plugin && that_present_plugin)) + return false; + if (!this.plugin.equals(that.plugin)) + return false; + } + + boolean this_present_func = true && this.isSetFunc(); + boolean that_present_func = true && that.isSetFunc(); + if (this_present_func || that_present_func) { + if (!(this_present_func && that_present_func)) + return false; + if (!this.func.equals(that.func)) + return false; + } + + return true; + } + + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_plugin = true && (isSetPlugin()); + list.add(present_plugin); + if (present_plugin) + list.add(plugin); - @Override - public int hashCode() { - return 0; - } + boolean present_func = true && (isSetFunc()); + list.add(present_func); + if (present_func) + list.add(func); - public int compareTo(ServiceDoesNotExists other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); + return list.hashCode(); } - int lastComparison = 0; - ServiceDoesNotExists typedOther = (ServiceDoesNotExists)other; - - lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(typedOther.isSetPlugin()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPlugin()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, typedOther.plugin); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetFunc()).compareTo(typedOther.isSetFunc()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetFunc()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, typedOther.func); - 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("ServiceDoesNotExists("); - boolean first = true; - - sb.append("plugin:"); - if (this.plugin == null) { - sb.append("null"); - } else { - sb.append(this.plugin); - } - first = false; - if (!first) sb.append(", "); - sb.append("func:"); - if (this.func == null) { - sb.append("null"); - } else { - sb.append(this.func); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - 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.getMessage()); - } - } - - private static class ServiceDoesNotExistsStandardSchemeFactory implements SchemeFactory { - public ServiceDoesNotExistsStandardScheme getScheme() { - return new ServiceDoesNotExistsStandardScheme(); - } - } - - private static class ServiceDoesNotExistsStandardScheme extends StandardScheme<ServiceDoesNotExists> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceDoesNotExists 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: // PLUGIN - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + @Override + public int compareTo(ServiceDoesNotExists other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } + + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetPlugin()).compareTo(other.isSetPlugin()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPlugin()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.plugin, other.plugin); + if (lastComparison != 0) { + return lastComparison; } - break; - case 2: // FUNC - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.func = iprot.readString(); - struct.setFuncIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetFunc()).compareTo(other.isSetFunc()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetFunc()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.func, other.func); + if (lastComparison != 0) { + return lastComparison; } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + return 0; + } + + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); + } - // check for required fields of primitive type, which can't be checked in the validate method - struct.validate(); + 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, ServiceDoesNotExists struct) throws org.apache.thrift.TException { - struct.validate(); + public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { + schemes.get(oprot.getScheme()).getScheme().write(oprot, this); + } - oprot.writeStructBegin(STRUCT_DESC); - if (struct.plugin != null) { - oprot.writeFieldBegin(PLUGIN_FIELD_DESC); - oprot.writeString(struct.plugin); - oprot.writeFieldEnd(); - } - if (struct.func != null) { - oprot.writeFieldBegin(FUNC_FIELD_DESC); - oprot.writeString(struct.func); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); + @Override + public String toString() { + StringBuilder sb = new StringBuilder("ServiceDoesNotExists("); + boolean first = true; + + sb.append("plugin:"); + if (this.plugin == null) { + sb.append("null"); + } else { + sb.append(this.plugin); + } + first = false; + if (!first) sb.append(", "); + sb.append("func:"); + if (this.func == null) { + sb.append("null"); + } else { + sb.append(this.func); + } + 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 static class ServiceDoesNotExistsTupleSchemeFactory implements SchemeFactory { - public ServiceDoesNotExistsTupleScheme getScheme() { - return new ServiceDoesNotExistsTupleScheme(); + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } } - } - private static class ServiceDoesNotExistsTupleScheme extends TupleScheme<ServiceDoesNotExists> { + 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); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ServiceDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetPlugin()) { - optionals.set(0); - } - if (struct.isSetFunc()) { - optionals.set(1); - } - oprot.writeBitSet(optionals, 2); - if (struct.isSetPlugin()) { - oprot.writeString(struct.plugin); - } - if (struct.isSetFunc()) { - oprot.writeString(struct.func); - } + private static class ServiceDoesNotExistsStandardSchemeFactory implements SchemeFactory { + public ServiceDoesNotExistsStandardScheme getScheme() { + return new ServiceDoesNotExistsStandardScheme(); + } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, ServiceDoesNotExists struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(2); - if (incoming.get(0)) { - struct.plugin = iprot.readString(); - struct.setPluginIsSet(true); - } - if (incoming.get(1)) { - struct.func = iprot.readString(); - struct.setFuncIsSet(true); - } - } - } + private static class ServiceDoesNotExistsStandardScheme extends StandardScheme<ServiceDoesNotExists> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceDoesNotExists 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: // PLUGIN + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 2: // FUNC + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.func = iprot.readString(); + struct.setFuncIsSet(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, ServiceDoesNotExists struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.plugin != null) { + oprot.writeFieldBegin(PLUGIN_FIELD_DESC); + oprot.writeString(struct.plugin); + oprot.writeFieldEnd(); + } + if (struct.func != null) { + oprot.writeFieldBegin(FUNC_FIELD_DESC); + oprot.writeString(struct.func); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ServiceDoesNotExistsTupleSchemeFactory implements SchemeFactory { + public ServiceDoesNotExistsTupleScheme getScheme() { + return new ServiceDoesNotExistsTupleScheme(); + } + } + + private static class ServiceDoesNotExistsTupleScheme extends TupleScheme<ServiceDoesNotExists> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ServiceDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetPlugin()) { + optionals.set(0); + } + if (struct.isSetFunc()) { + optionals.set(1); + } + oprot.writeBitSet(optionals, 2); + if (struct.isSetPlugin()) { + oprot.writeString(struct.plugin); + } + if (struct.isSetFunc()) { + oprot.writeString(struct.func); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ServiceDoesNotExists struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(2); + if (incoming.get(0)) { + struct.plugin = iprot.readString(); + struct.setPluginIsSet(true); + } + if (incoming.get(1)) { + struct.func = iprot.readString(); + struct.setFuncIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/ServiceException.java b/app/src/main/java/org/pyload/thrift/ServiceException.java index d8af700..4832d99 100644 --- a/app/src/main/java/org/pyload/thrift/ServiceException.java +++ b/app/src/main/java/org/pyload/thrift/ServiceException.java @@ -1,382 +1,414 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.TException; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class ServiceException extends Exception implements org.apache.thrift.TBase<ServiceException, ServiceException._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceException"); - - private static final org.apache.thrift.protocol.TField MSG_FIELD_DESC = new org.apache.thrift.protocol.TField("msg", org.apache.thrift.protocol.TType.STRING, (short)1); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new ServiceExceptionStandardSchemeFactory()); - schemes.put(TupleScheme.class, new ServiceExceptionTupleSchemeFactory()); - } +import java.util.HashMap; +import java.util.List; +import java.util.Map; - public String msg; // required +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class ServiceException extends TException implements org.apache.thrift.TBase<ServiceException, ServiceException._Fields>, java.io.Serializable, Cloneable, Comparable<ServiceException>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("ServiceException"); - /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ - public enum _Fields implements org.apache.thrift.TFieldIdEnum { - MSG((short)1, "msg"); + private static final org.apache.thrift.protocol.TField MSG_FIELD_DESC = new org.apache.thrift.protocol.TField("msg", org.apache.thrift.protocol.TType.STRING, (short) 1); - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new ServiceExceptionStandardSchemeFactory()); + schemes.put(TupleScheme.class, new ServiceExceptionTupleSchemeFactory()); } - /** - * Find the _Fields constant that matches fieldId, or null if its not found. - */ - public static _Fields findByThriftId(int fieldId) { - switch(fieldId) { - case 1: // MSG - return MSG; - default: - return null; - } + public String msg; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + out.writeString(msg); } - /** - * 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; + @Override + public int describeContents() { + return 0; } - /** - * Find the _Fields constant that matches name, or null if its not found. - */ - public static _Fields findByName(String name) { - return byName.get(name); + public ServiceException(android.os.Parcel in) { + this.msg = in.readString(); } - private final short _thriftId; - private final String _fieldName; + public static final android.os.Parcelable.Creator<ServiceException> CREATOR = new android.os.Parcelable.Creator<ServiceException>() { + @Override + public ServiceException[] newArray(int size) { + return new ServiceException[size]; + } - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } + @Override + public ServiceException createFromParcel(android.os.Parcel in) { + return new ServiceException(in); + } + }; - public short getThriftFieldId() { - return _thriftId; - } + /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */ + public enum _Fields implements org.apache.thrift.TFieldIdEnum { + MSG((short) 1, "msg"); - public String getFieldName() { - return _fieldName; - } - } + private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); - // isset id assignments - public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - static { - Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); - tmpMap.put(_Fields.MSG, new org.apache.thrift.meta_data.FieldMetaData("msg", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceException.class, metaDataMap); - } + static { + for (_Fields field : EnumSet.allOf(_Fields.class)) { + byName.put(field.getFieldName(), field); + } + } - public ServiceException() { - } + /** + * Find the _Fields constant that matches fieldId, or null if its not found. + */ + public static _Fields findByThriftId(int fieldId) { + switch (fieldId) { + case 1: // MSG + return MSG; + default: + return null; + } + } - public ServiceException( - String msg) - { - this(); - this.msg = msg; - } + /** + * 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; + } - /** - * Performs a deep copy on <i>other</i>. - */ - public ServiceException(ServiceException other) { - if (other.isSetMsg()) { - this.msg = other.msg; - } - } + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } - public ServiceException deepCopy() { - return new ServiceException(this); - } + private final short _thriftId; + private final String _fieldName; - @Override - public void clear() { - this.msg = null; - } + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } - public String getMsg() { - return this.msg; - } + public short getThriftFieldId() { + return _thriftId; + } - public ServiceException setMsg(String msg) { - this.msg = msg; - return this; - } + public String getFieldName() { + return _fieldName; + } + } - public void unsetMsg() { - this.msg = null; - } + // isset id assignments + public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap; - /** Returns true if field msg is set (has been assigned a value) and false otherwise */ - public boolean isSetMsg() { - return this.msg != null; - } + static { + Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class); + tmpMap.put(_Fields.MSG, new org.apache.thrift.meta_data.FieldMetaData("msg", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(ServiceException.class, metaDataMap); + } - public void setMsgIsSet(boolean value) { - if (!value) { - this.msg = null; + public ServiceException() { } - } - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case MSG: - if (value == null) { - unsetMsg(); - } else { - setMsg((String)value); - } - break; + public ServiceException( + String msg) { + this(); + this.msg = msg; + } + /** + * Performs a deep copy on <i>other</i>. + */ + public ServiceException(ServiceException other) { + if (other.isSetMsg()) { + this.msg = other.msg; + } } - } - public Object getFieldValue(_Fields field) { - switch (field) { - case MSG: - return getMsg(); + public ServiceException deepCopy() { + return new ServiceException(this); + } + @Override + public void clear() { + this.msg = null; } - 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(); + public String getMsg() { + return this.msg; } - switch (field) { - case MSG: - return isSetMsg(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof ServiceException) - return this.equals((ServiceException)that); - return false; - } - - public boolean equals(ServiceException that) { - if (that == null) - return false; - - boolean this_present_msg = true && this.isSetMsg(); - boolean that_present_msg = true && that.isSetMsg(); - if (this_present_msg || that_present_msg) { - if (!(this_present_msg && that_present_msg)) - return false; - if (!this.msg.equals(that.msg)) - return false; + public ServiceException setMsg(String msg) { + this.msg = msg; + return this; } - return true; - } + public void unsetMsg() { + this.msg = null; + } - @Override - public int hashCode() { - return 0; - } + /** Returns true if field msg is set (has been assigned a value) and false otherwise */ + public boolean isSetMsg() { + return this.msg != null; + } - public int compareTo(ServiceException other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); + public void setMsgIsSet(boolean value) { + if (!value) { + this.msg = null; + } } - int lastComparison = 0; - ServiceException typedOther = (ServiceException)other; + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case MSG: + if (value == null) { + unsetMsg(); + } else { + setMsg((String) value); + } + break; - lastComparison = Boolean.valueOf(isSetMsg()).compareTo(typedOther.isSetMsg()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetMsg()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, typedOther.msg); - if (lastComparison != 0) { - return lastComparison; - } + } } - return 0; - } - public _Fields fieldForId(int fieldId) { - return _Fields.findByThriftId(fieldId); - } + public Object getFieldValue(_Fields field) { + switch (field) { + case MSG: + return getMsg(); - public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { - schemes.get(iprot.getScheme()).getScheme().read(iprot, this); - } + } + throw new IllegalStateException(); + } - public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException { - schemes.get(oprot.getScheme()).getScheme().write(oprot, this); - } + /** 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(); + } - @Override - public String toString() { - StringBuilder sb = new StringBuilder("ServiceException("); - boolean first = true; + switch (field) { + case MSG: + return isSetMsg(); + } + throw new IllegalStateException(); + } - sb.append("msg:"); - if (this.msg == null) { - sb.append("null"); - } else { - sb.append(this.msg); + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof ServiceException) + return this.equals((ServiceException) that); + return false; } - first = false; - sb.append(")"); - return sb.toString(); - } - public void validate() throws org.apache.thrift.TException { - // check for required fields - } + public boolean equals(ServiceException that) { + if (that == null) + return false; + + boolean this_present_msg = true && this.isSetMsg(); + boolean that_present_msg = true && that.isSetMsg(); + if (this_present_msg || that_present_msg) { + if (!(this_present_msg && that_present_msg)) + return false; + if (!this.msg.equals(that.msg)) + return false; + } - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); + return true; } - } - 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.getMessage()); - } - } + @Override + public int hashCode() { + List<Object> list = new ArrayList<Object>(); + + boolean present_msg = true && (isSetMsg()); + list.add(present_msg); + if (present_msg) + list.add(msg); - private static class ServiceExceptionStandardSchemeFactory implements SchemeFactory { - public ServiceExceptionStandardScheme getScheme() { - return new ServiceExceptionStandardScheme(); + return list.hashCode(); } - } - private static class ServiceExceptionStandardScheme extends StandardScheme<ServiceException> { + @Override + public int compareTo(ServiceException other) { + if (!getClass().equals(other.getClass())) { + return getClass().getName().compareTo(other.getClass().getName()); + } - public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceException 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; + int lastComparison = 0; + + lastComparison = Boolean.valueOf(isSetMsg()).compareTo(other.isSetMsg()); + if (lastComparison != 0) { + return lastComparison; } - switch (schemeField.id) { - case 1: // MSG - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.msg = iprot.readString(); - struct.setMsgIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + if (isSetMsg()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.msg, other.msg); + if (lastComparison != 0) { + return lastComparison; } - break; - default: - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); } - iprot.readFieldEnd(); - } - iprot.readStructEnd(); + return 0; + } - // check for required fields of primitive type, which can't be checked in the validate method - struct.validate(); + public _Fields fieldForId(int fieldId) { + return _Fields.findByThriftId(fieldId); } - public void write(org.apache.thrift.protocol.TProtocol oprot, ServiceException struct) throws org.apache.thrift.TException { - struct.validate(); + public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException { + schemes.get(iprot.getScheme()).getScheme().read(iprot, this); + } - oprot.writeStructBegin(STRUCT_DESC); - if (struct.msg != null) { - oprot.writeFieldBegin(MSG_FIELD_DESC); - oprot.writeString(struct.msg); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); + 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("ServiceException("); + boolean first = true; + + sb.append("msg:"); + if (this.msg == null) { + sb.append("null"); + } else { + sb.append(this.msg); + } + first = false; + sb.append(")"); + return sb.toString(); + } - private static class ServiceExceptionTupleSchemeFactory implements SchemeFactory { - public ServiceExceptionTupleScheme getScheme() { - return new ServiceExceptionTupleScheme(); + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity } - } - private static class ServiceExceptionTupleScheme extends TupleScheme<ServiceException> { + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, ServiceException struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetMsg()) { - optionals.set(0); - } - oprot.writeBitSet(optionals, 1); - if (struct.isSetMsg()) { - oprot.writeString(struct.msg); - } + 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); + } } - @Override - public void read(org.apache.thrift.protocol.TProtocol prot, ServiceException struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(1); - if (incoming.get(0)) { - struct.msg = iprot.readString(); - struct.setMsgIsSet(true); - } - } - } + private static class ServiceExceptionStandardSchemeFactory implements SchemeFactory { + public ServiceExceptionStandardScheme getScheme() { + return new ServiceExceptionStandardScheme(); + } + } + + private static class ServiceExceptionStandardScheme extends StandardScheme<ServiceException> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, ServiceException 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: // MSG + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(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, ServiceException struct) throws org.apache.thrift.TException { + struct.validate(); + + oprot.writeStructBegin(STRUCT_DESC); + if (struct.msg != null) { + oprot.writeFieldBegin(MSG_FIELD_DESC); + oprot.writeString(struct.msg); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class ServiceExceptionTupleSchemeFactory implements SchemeFactory { + public ServiceExceptionTupleScheme getScheme() { + return new ServiceExceptionTupleScheme(); + } + } + + private static class ServiceExceptionTupleScheme extends TupleScheme<ServiceException> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, ServiceException struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetMsg()) { + optionals.set(0); + } + oprot.writeBitSet(optionals, 1); + if (struct.isSetMsg()) { + oprot.writeString(struct.msg); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, ServiceException struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(1); + if (incoming.get(0)) { + struct.msg = iprot.readString(); + struct.setMsgIsSet(true); + } + } + } } diff --git a/app/src/main/java/org/pyload/thrift/UserData.java b/app/src/main/java/org/pyload/thrift/UserData.java index 213f1dd..c1f6c4d 100644 --- a/app/src/main/java/org/pyload/thrift/UserData.java +++ b/app/src/main/java/org/pyload/thrift/UserData.java @@ -1,775 +1,840 @@ /** - * Autogenerated by Thrift Compiler (0.8.0-dev) - * + * Autogenerated by Thrift Compiler (0.9.3) + * <p> * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING - * @generated + * + * @generated */ package org.pyload.thrift; +import org.apache.thrift.EncodingUtils; +import org.apache.thrift.protocol.TTupleProtocol; 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 java.util.List; + import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; +import java.util.BitSet; +import java.util.Collections; import java.util.EnumMap; -import java.util.Set; -import java.util.HashSet; import java.util.EnumSet; -import java.util.Collections; -import java.util.BitSet; -import java.nio.ByteBuffer; -import java.util.Arrays; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class UserData implements org.apache.thrift.TBase<UserData, UserData._Fields>, java.io.Serializable, Cloneable { - private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("UserData"); - - 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 EMAIL_FIELD_DESC = new org.apache.thrift.protocol.TField("email", org.apache.thrift.protocol.TType.STRING, (short)2); - private static final org.apache.thrift.protocol.TField ROLE_FIELD_DESC = new org.apache.thrift.protocol.TField("role", org.apache.thrift.protocol.TType.I32, (short)3); - private static final org.apache.thrift.protocol.TField PERMISSION_FIELD_DESC = new org.apache.thrift.protocol.TField("permission", org.apache.thrift.protocol.TType.I32, (short)4); - private static final org.apache.thrift.protocol.TField TEMPLATE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("templateName", org.apache.thrift.protocol.TType.STRING, (short)5); - - private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); - static { - schemes.put(StandardScheme.class, new UserDataStandardSchemeFactory()); - schemes.put(TupleScheme.class, new UserDataTupleSchemeFactory()); - } - - public String name; // required - public String email; // required - public int role; // required - public int permission; // required - public String templateName; // 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"), - EMAIL((short)2, "email"), - ROLE((short)3, "role"), - PERMISSION((short)4, "permission"), - TEMPLATE_NAME((short)5, "templateName"); - - private static final Map<String, _Fields> byName = new HashMap<String, _Fields>(); +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"}) +public class UserData implements org.apache.thrift.TBase<UserData, UserData._Fields>, java.io.Serializable, Cloneable, Comparable<UserData>, android.os.Parcelable { + private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("UserData"); + + 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 EMAIL_FIELD_DESC = new org.apache.thrift.protocol.TField("email", org.apache.thrift.protocol.TType.STRING, (short) 2); + private static final org.apache.thrift.protocol.TField ROLE_FIELD_DESC = new org.apache.thrift.protocol.TField("role", org.apache.thrift.protocol.TType.I32, (short) 3); + private static final org.apache.thrift.protocol.TField PERMISSION_FIELD_DESC = new org.apache.thrift.protocol.TField("permission", org.apache.thrift.protocol.TType.I32, (short) 4); + private static final org.apache.thrift.protocol.TField TEMPLATE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("templateName", org.apache.thrift.protocol.TType.STRING, (short) 5); + + private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>(); static { - for (_Fields field : EnumSet.allOf(_Fields.class)) { - byName.put(field.getFieldName(), field); - } + schemes.put(StandardScheme.class, new UserDataStandardSchemeFactory()); + schemes.put(TupleScheme.class, new UserDataTupleSchemeFactory()); } - /** - * 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: // EMAIL - return EMAIL; - case 3: // ROLE - return ROLE; - case 4: // PERMISSION - return PERMISSION; - case 5: // TEMPLATE_NAME - return TEMPLATE_NAME; - default: - return null; - } + public String name; // required + public String email; // required + public int role; // required + public int permission; // required + public String templateName; // required + + @Override + public void writeToParcel(android.os.Parcel out, int flags) { + //primitive bitfield of type: byte + out.writeByte(__isset_bitfield); + + out.writeString(name); + out.writeString(email); + out.writeInt(role); + out.writeInt(permission); + out.writeString(templateName); } - /** - * 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; + @Override + public int describeContents() { + return 0; + } + + public UserData(android.os.Parcel in) { + //primitive bitfield of type: byte + __isset_bitfield = in.readByte(); + + this.name = in.readString(); + this.email = in.readString(); + this.role = in.readInt(); + this.permission = in.readInt(); + this.templateName = in.readString(); + } + + public static final android.os.Parcelable.Creator<UserData> CREATOR = new android.os.Parcelable.Creator<UserData>() { + @Override + public UserData[] newArray(int size) { + return new UserData[size]; + } + + @Override + public UserData createFromParcel(android.os.Parcel in) { + return new UserData(in); + } + }; + + /** 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"), + EMAIL((short) 2, "email"), + ROLE((short) 3, "role"), + PERMISSION((short) 4, "permission"), + TEMPLATE_NAME((short) 5, "templateName"); + + 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: // EMAIL + return EMAIL; + case 3: // ROLE + return ROLE; + case 4: // PERMISSION + return PERMISSION; + case 5: // TEMPLATE_NAME + return TEMPLATE_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 IllegalArgumentException("Field " + fieldId + " doesn't exist!"); + return fields; + } + + /** + * Find the _Fields constant that matches name, or null if its not found. + */ + public static _Fields findByName(String name) { + return byName.get(name); + } + + private final short _thriftId; + private final String _fieldName; + + _Fields(short thriftId, String fieldName) { + _thriftId = thriftId; + _fieldName = fieldName; + } + + public short getThriftFieldId() { + return _thriftId; + } + + public String getFieldName() { + return _fieldName; + } + } + + // isset id assignments + private static final int __ROLE_ISSET_ID = 0; + private static final int __PERMISSION_ISSET_ID = 1; + private byte __isset_bitfield = 0; + 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.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.EMAIL, new org.apache.thrift.meta_data.FieldMetaData("email", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + tmpMap.put(_Fields.ROLE, new org.apache.thrift.meta_data.FieldMetaData("role", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.PERMISSION, new org.apache.thrift.meta_data.FieldMetaData("permission", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); + tmpMap.put(_Fields.TEMPLATE_NAME, new org.apache.thrift.meta_data.FieldMetaData("templateName", org.apache.thrift.TFieldRequirementType.DEFAULT, + new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); + metaDataMap = Collections.unmodifiableMap(tmpMap); + org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(UserData.class, metaDataMap); + } + + public UserData() { + } + + public UserData( + String name, + String email, + int role, + int permission, + String templateName) { + this(); + this.name = name; + this.email = email; + this.role = role; + setRoleIsSet(true); + this.permission = permission; + setPermissionIsSet(true); + this.templateName = templateName; } /** - * Find the _Fields constant that matches name, or null if its not found. + * Performs a deep copy on <i>other</i>. */ - public static _Fields findByName(String name) { - return byName.get(name); - } - - private final short _thriftId; - private final String _fieldName; - - _Fields(short thriftId, String fieldName) { - _thriftId = thriftId; - _fieldName = fieldName; - } - - public short getThriftFieldId() { - return _thriftId; - } - - public String getFieldName() { - return _fieldName; - } - } - - // isset id assignments - private static final int __ROLE_ISSET_ID = 0; - private static final int __PERMISSION_ISSET_ID = 1; - private BitSet __isset_bit_vector = new BitSet(2); - 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.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.EMAIL, new org.apache.thrift.meta_data.FieldMetaData("email", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - tmpMap.put(_Fields.ROLE, new org.apache.thrift.meta_data.FieldMetaData("role", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); - tmpMap.put(_Fields.PERMISSION, new org.apache.thrift.meta_data.FieldMetaData("permission", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))); - tmpMap.put(_Fields.TEMPLATE_NAME, new org.apache.thrift.meta_data.FieldMetaData("templateName", org.apache.thrift.TFieldRequirementType.DEFAULT, - new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))); - metaDataMap = Collections.unmodifiableMap(tmpMap); - org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(UserData.class, metaDataMap); - } - - public UserData() { - } - - public UserData( - String name, - String email, - int role, - int permission, - String templateName) - { - this(); - this.name = name; - this.email = email; - this.role = role; - setRoleIsSet(true); - this.permission = permission; - setPermissionIsSet(true); - this.templateName = templateName; - } - - /** - * Performs a deep copy on <i>other</i>. - */ - public UserData(UserData other) { - __isset_bit_vector.clear(); - __isset_bit_vector.or(other.__isset_bit_vector); - if (other.isSetName()) { - this.name = other.name; - } - if (other.isSetEmail()) { - this.email = other.email; - } - this.role = other.role; - this.permission = other.permission; - if (other.isSetTemplateName()) { - this.templateName = other.templateName; - } - } - - public UserData deepCopy() { - return new UserData(this); - } - - @Override - public void clear() { - this.name = null; - this.email = null; - setRoleIsSet(false); - this.role = 0; - setPermissionIsSet(false); - this.permission = 0; - this.templateName = null; - } - - public String getName() { - return this.name; - } - - public UserData setName(String name) { - this.name = name; - return this; - } - - public void unsetName() { - this.name = null; - } - - /** Returns true if field name is set (has been assigned a value) and false otherwise */ - public boolean isSetName() { - return this.name != null; - } - - public void setNameIsSet(boolean value) { - if (!value) { - this.name = null; - } - } - - public String getEmail() { - return this.email; - } - - public UserData setEmail(String email) { - this.email = email; - return this; - } - - public void unsetEmail() { - this.email = null; - } - - /** Returns true if field email is set (has been assigned a value) and false otherwise */ - public boolean isSetEmail() { - return this.email != null; - } - - public void setEmailIsSet(boolean value) { - if (!value) { - this.email = null; - } - } - - public int getRole() { - return this.role; - } - - public UserData setRole(int role) { - this.role = role; - setRoleIsSet(true); - return this; - } - - public void unsetRole() { - __isset_bit_vector.clear(__ROLE_ISSET_ID); - } - - /** Returns true if field role is set (has been assigned a value) and false otherwise */ - public boolean isSetRole() { - return __isset_bit_vector.get(__ROLE_ISSET_ID); - } - - public void setRoleIsSet(boolean value) { - __isset_bit_vector.set(__ROLE_ISSET_ID, value); - } - - public int getPermission() { - return this.permission; - } - - public UserData setPermission(int permission) { - this.permission = permission; - setPermissionIsSet(true); - return this; - } - - public void unsetPermission() { - __isset_bit_vector.clear(__PERMISSION_ISSET_ID); - } - - /** Returns true if field permission is set (has been assigned a value) and false otherwise */ - public boolean isSetPermission() { - return __isset_bit_vector.get(__PERMISSION_ISSET_ID); - } - - public void setPermissionIsSet(boolean value) { - __isset_bit_vector.set(__PERMISSION_ISSET_ID, value); - } - - public String getTemplateName() { - return this.templateName; - } - - public UserData setTemplateName(String templateName) { - this.templateName = templateName; - return this; - } - - public void unsetTemplateName() { - this.templateName = null; - } - - /** Returns true if field templateName is set (has been assigned a value) and false otherwise */ - public boolean isSetTemplateName() { - return this.templateName != null; - } - - public void setTemplateNameIsSet(boolean value) { - if (!value) { - this.templateName = null; - } - } - - public void setFieldValue(_Fields field, Object value) { - switch (field) { - case NAME: - if (value == null) { - unsetName(); - } else { - setName((String)value); - } - break; - - case EMAIL: - if (value == null) { - unsetEmail(); - } else { - setEmail((String)value); - } - break; - - case ROLE: - if (value == null) { - unsetRole(); - } else { - setRole((Integer)value); - } - break; - - case PERMISSION: - if (value == null) { - unsetPermission(); - } else { - setPermission((Integer)value); - } - break; - - case TEMPLATE_NAME: - if (value == null) { - unsetTemplateName(); - } else { - setTemplateName((String)value); - } - break; - - } - } - - public Object getFieldValue(_Fields field) { - switch (field) { - case NAME: - return getName(); - - case EMAIL: - return getEmail(); - - case ROLE: - return Integer.valueOf(getRole()); - - case PERMISSION: - return Integer.valueOf(getPermission()); - - case TEMPLATE_NAME: - return getTemplateName(); - - } - 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 EMAIL: - return isSetEmail(); - case ROLE: - return isSetRole(); - case PERMISSION: - return isSetPermission(); - case TEMPLATE_NAME: - return isSetTemplateName(); - } - throw new IllegalStateException(); - } - - @Override - public boolean equals(Object that) { - if (that == null) - return false; - if (that instanceof UserData) - return this.equals((UserData)that); - return false; - } - - public boolean equals(UserData 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; + public UserData(UserData other) { + __isset_bitfield = other.__isset_bitfield; + if (other.isSetName()) { + this.name = other.name; + } + if (other.isSetEmail()) { + this.email = other.email; + } + this.role = other.role; + this.permission = other.permission; + if (other.isSetTemplateName()) { + this.templateName = other.templateName; + } } - boolean this_present_email = true && this.isSetEmail(); - boolean that_present_email = true && that.isSetEmail(); - if (this_present_email || that_present_email) { - if (!(this_present_email && that_present_email)) - return false; - if (!this.email.equals(that.email)) - return false; + public UserData deepCopy() { + return new UserData(this); } - boolean this_present_role = true; - boolean that_present_role = true; - if (this_present_role || that_present_role) { - if (!(this_present_role && that_present_role)) - return false; - if (this.role != that.role) - return false; + @Override + public void clear() { + this.name = null; + this.email = null; + setRoleIsSet(false); + this.role = 0; + setPermissionIsSet(false); + this.permission = 0; + this.templateName = null; } - boolean this_present_permission = true; - boolean that_present_permission = true; - if (this_present_permission || that_present_permission) { - if (!(this_present_permission && that_present_permission)) - return false; - if (this.permission != that.permission) - return false; + public String getName() { + return this.name; } - boolean this_present_templateName = true && this.isSetTemplateName(); - boolean that_present_templateName = true && that.isSetTemplateName(); - if (this_present_templateName || that_present_templateName) { - if (!(this_present_templateName && that_present_templateName)) - return false; - if (!this.templateName.equals(that.templateName)) + public UserData setName(String name) { + this.name = name; + return this; + } + + public void unsetName() { + this.name = null; + } + + /** Returns true if field name is set (has been assigned a value) and false otherwise */ + public boolean isSetName() { + return this.name != null; + } + + public void setNameIsSet(boolean value) { + if (!value) { + this.name = null; + } + } + + public String getEmail() { + return this.email; + } + + public UserData setEmail(String email) { + this.email = email; + return this; + } + + public void unsetEmail() { + this.email = null; + } + + /** Returns true if field email is set (has been assigned a value) and false otherwise */ + public boolean isSetEmail() { + return this.email != null; + } + + public void setEmailIsSet(boolean value) { + if (!value) { + this.email = null; + } + } + + public int getRole() { + return this.role; + } + + public UserData setRole(int role) { + this.role = role; + setRoleIsSet(true); + return this; + } + + public void unsetRole() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ROLE_ISSET_ID); + } + + /** Returns true if field role is set (has been assigned a value) and false otherwise */ + public boolean isSetRole() { + return EncodingUtils.testBit(__isset_bitfield, __ROLE_ISSET_ID); + } + + public void setRoleIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ROLE_ISSET_ID, value); + } + + public int getPermission() { + return this.permission; + } + + public UserData setPermission(int permission) { + this.permission = permission; + setPermissionIsSet(true); + return this; + } + + public void unsetPermission() { + __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __PERMISSION_ISSET_ID); + } + + /** Returns true if field permission is set (has been assigned a value) and false otherwise */ + public boolean isSetPermission() { + return EncodingUtils.testBit(__isset_bitfield, __PERMISSION_ISSET_ID); + } + + public void setPermissionIsSet(boolean value) { + __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __PERMISSION_ISSET_ID, value); + } + + public String getTemplateName() { + return this.templateName; + } + + public UserData setTemplateName(String templateName) { + this.templateName = templateName; + return this; + } + + public void unsetTemplateName() { + this.templateName = null; + } + + /** Returns true if field templateName is set (has been assigned a value) and false otherwise */ + public boolean isSetTemplateName() { + return this.templateName != null; + } + + public void setTemplateNameIsSet(boolean value) { + if (!value) { + this.templateName = null; + } + } + + public void setFieldValue(_Fields field, Object value) { + switch (field) { + case NAME: + if (value == null) { + unsetName(); + } else { + setName((String) value); + } + break; + + case EMAIL: + if (value == null) { + unsetEmail(); + } else { + setEmail((String) value); + } + break; + + case ROLE: + if (value == null) { + unsetRole(); + } else { + setRole((Integer) value); + } + break; + + case PERMISSION: + if (value == null) { + unsetPermission(); + } else { + setPermission((Integer) value); + } + break; + + case TEMPLATE_NAME: + if (value == null) { + unsetTemplateName(); + } else { + setTemplateName((String) value); + } + break; + + } + } + + public Object getFieldValue(_Fields field) { + switch (field) { + case NAME: + return getName(); + + case EMAIL: + return getEmail(); + + case ROLE: + return getRole(); + + case PERMISSION: + return getPermission(); + + case TEMPLATE_NAME: + return getTemplateName(); + + } + 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 EMAIL: + return isSetEmail(); + case ROLE: + return isSetRole(); + case PERMISSION: + return isSetPermission(); + case TEMPLATE_NAME: + return isSetTemplateName(); + } + throw new IllegalStateException(); + } + + @Override + public boolean equals(Object that) { + if (that == null) + return false; + if (that instanceof UserData) + return this.equals((UserData) that); return false; } - return true; - } - - @Override - public int hashCode() { - return 0; - } - - public int compareTo(UserData other) { - if (!getClass().equals(other.getClass())) { - return getClass().getName().compareTo(other.getClass().getName()); - } - - int lastComparison = 0; - UserData typedOther = (UserData)other; - - lastComparison = Boolean.valueOf(isSetName()).compareTo(typedOther.isSetName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.name, typedOther.name); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetEmail()).compareTo(typedOther.isSetEmail()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetEmail()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.email, typedOther.email); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetRole()).compareTo(typedOther.isSetRole()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetRole()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.role, typedOther.role); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetPermission()).compareTo(typedOther.isSetPermission()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetPermission()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.permission, typedOther.permission); - if (lastComparison != 0) { - return lastComparison; - } - } - lastComparison = Boolean.valueOf(isSetTemplateName()).compareTo(typedOther.isSetTemplateName()); - if (lastComparison != 0) { - return lastComparison; - } - if (isSetTemplateName()) { - lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.templateName, typedOther.templateName); - 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("UserData("); - boolean first = true; - - sb.append("name:"); - if (this.name == null) { - sb.append("null"); - } else { - sb.append(this.name); - } - first = false; - if (!first) sb.append(", "); - sb.append("email:"); - if (this.email == null) { - sb.append("null"); - } else { - sb.append(this.email); - } - first = false; - if (!first) sb.append(", "); - sb.append("role:"); - sb.append(this.role); - first = false; - if (!first) sb.append(", "); - sb.append("permission:"); - sb.append(this.permission); - first = false; - if (!first) sb.append(", "); - sb.append("templateName:"); - if (this.templateName == null) { - sb.append("null"); - } else { - sb.append(this.templateName); - } - first = false; - sb.append(")"); - return sb.toString(); - } - - public void validate() throws org.apache.thrift.TException { - // check for required fields - } - - private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { - try { - write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { - try { - // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. - __isset_bit_vector = new BitSet(1); - read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); - } catch (org.apache.thrift.TException te) { - throw new java.io.IOException(te.getMessage()); - } - } - - private static class UserDataStandardSchemeFactory implements SchemeFactory { - public UserDataStandardScheme getScheme() { - return new UserDataStandardScheme(); - } - } - - private static class UserDataStandardScheme extends StandardScheme<UserData> { - - public void read(org.apache.thrift.protocol.TProtocol iprot, UserData 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); + public boolean equals(UserData 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_email = true && this.isSetEmail(); + boolean that_present_email = true && that.isSetEmail(); + if (this_present_email || that_present_email) { + if (!(this_present_email && that_present_email)) + return false; + if (!this.email.equals(that.email)) + return false; + } + + boolean this_present_role = true; + boolean that_present_role = true; + if (this_present_role || that_present_role) { + if (!(this_present_role && that_present_role)) + return false; + if (this.role != that.role) + return false; + } + + boolean this_present_permission = true; + boolean that_present_permission = true; + if (this_present_permission || that_present_permission) { + if (!(this_present_permission && that_present_permission)) + return false; + if (this.permission != that.permission) + return false; + } + + boolean this_present_templateName = true && this.isSetTemplateName(); + boolean that_present_templateName = true && that.isSetTemplateName(); + if (this_present_templateName || that_present_templateName) { + if (!(this_present_templateName && that_present_templateName)) + return false; + if (!this.templateName.equals(that.templateName)) + 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_email = true && (isSetEmail()); + list.add(present_email); + if (present_email) + list.add(email); + + boolean present_role = true; + list.add(present_role); + if (present_role) + list.add(role); + + boolean present_permission = true; + list.add(present_permission); + if (present_permission) + list.add(permission); + + boolean present_templateName = true && (isSetTemplateName()); + list.add(present_templateName); + if (present_templateName) + list.add(templateName); + + return list.hashCode(); + } + + @Override + public int compareTo(UserData 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; } - break; - case 2: // EMAIL - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.email = iprot.readString(); - struct.setEmailIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetEmail()).compareTo(other.isSetEmail()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetEmail()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.email, other.email); + if (lastComparison != 0) { + return lastComparison; } - break; - case 3: // ROLE - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.role = iprot.readI32(); - struct.setRoleIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetRole()).compareTo(other.isSetRole()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetRole()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.role, other.role); + if (lastComparison != 0) { + return lastComparison; } - break; - case 4: // PERMISSION - if (schemeField.type == org.apache.thrift.protocol.TType.I32) { - struct.permission = iprot.readI32(); - struct.setPermissionIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetPermission()).compareTo(other.isSetPermission()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetPermission()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.permission, other.permission); + if (lastComparison != 0) { + return lastComparison; } - break; - case 5: // TEMPLATE_NAME - if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { - struct.templateName = iprot.readString(); - struct.setTemplateNameIsSet(true); - } else { - org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + lastComparison = Boolean.valueOf(isSetTemplateName()).compareTo(other.isSetTemplateName()); + if (lastComparison != 0) { + return lastComparison; + } + if (isSetTemplateName()) { + lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.templateName, other.templateName); + if (lastComparison != 0) { + return lastComparison; } - 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, UserData 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.email != null) { - oprot.writeFieldBegin(EMAIL_FIELD_DESC); - oprot.writeString(struct.email); - oprot.writeFieldEnd(); - } - oprot.writeFieldBegin(ROLE_FIELD_DESC); - oprot.writeI32(struct.role); - oprot.writeFieldEnd(); - oprot.writeFieldBegin(PERMISSION_FIELD_DESC); - oprot.writeI32(struct.permission); - oprot.writeFieldEnd(); - if (struct.templateName != null) { - oprot.writeFieldBegin(TEMPLATE_NAME_FIELD_DESC); - oprot.writeString(struct.templateName); - oprot.writeFieldEnd(); - } - oprot.writeFieldStop(); - oprot.writeStructEnd(); - } - - } - - private static class UserDataTupleSchemeFactory implements SchemeFactory { - public UserDataTupleScheme getScheme() { - return new UserDataTupleScheme(); - } - } - - private static class UserDataTupleScheme extends TupleScheme<UserData> { + } + return 0; + } - @Override - public void write(org.apache.thrift.protocol.TProtocol prot, UserData struct) throws org.apache.thrift.TException { - TTupleProtocol oprot = (TTupleProtocol) prot; - BitSet optionals = new BitSet(); - if (struct.isSetName()) { - optionals.set(0); - } - if (struct.isSetEmail()) { - optionals.set(1); - } - if (struct.isSetRole()) { - optionals.set(2); - } - if (struct.isSetPermission()) { - optionals.set(3); - } - if (struct.isSetTemplateName()) { - optionals.set(4); - } - oprot.writeBitSet(optionals, 5); - if (struct.isSetName()) { - oprot.writeString(struct.name); - } - if (struct.isSetEmail()) { - oprot.writeString(struct.email); - } - if (struct.isSetRole()) { - oprot.writeI32(struct.role); - } - if (struct.isSetPermission()) { - oprot.writeI32(struct.permission); - } - if (struct.isSetTemplateName()) { - oprot.writeString(struct.templateName); - } + 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 void read(org.apache.thrift.protocol.TProtocol prot, UserData struct) throws org.apache.thrift.TException { - TTupleProtocol iprot = (TTupleProtocol) prot; - BitSet incoming = iprot.readBitSet(5); - if (incoming.get(0)) { - struct.name = iprot.readString(); - struct.setNameIsSet(true); - } - if (incoming.get(1)) { - struct.email = iprot.readString(); - struct.setEmailIsSet(true); - } - if (incoming.get(2)) { - struct.role = iprot.readI32(); - struct.setRoleIsSet(true); - } - if (incoming.get(3)) { - struct.permission = iprot.readI32(); - struct.setPermissionIsSet(true); - } - if (incoming.get(4)) { - struct.templateName = iprot.readString(); - struct.setTemplateNameIsSet(true); - } - } - } + public String toString() { + StringBuilder sb = new StringBuilder("UserData("); + boolean first = true; + + sb.append("name:"); + if (this.name == null) { + sb.append("null"); + } else { + sb.append(this.name); + } + first = false; + if (!first) sb.append(", "); + sb.append("email:"); + if (this.email == null) { + sb.append("null"); + } else { + sb.append(this.email); + } + first = false; + if (!first) sb.append(", "); + sb.append("role:"); + sb.append(this.role); + first = false; + if (!first) sb.append(", "); + sb.append("permission:"); + sb.append(this.permission); + first = false; + if (!first) sb.append(", "); + sb.append("templateName:"); + if (this.templateName == null) { + sb.append("null"); + } else { + sb.append(this.templateName); + } + first = false; + sb.append(")"); + return sb.toString(); + } + + public void validate() throws org.apache.thrift.TException { + // check for required fields + // check for sub-struct validity + } + + private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException { + try { + write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out))); + } catch (org.apache.thrift.TException te) { + throw new java.io.IOException(te); + } + } + + private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { + try { + // 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 UserDataStandardSchemeFactory implements SchemeFactory { + public UserDataStandardScheme getScheme() { + return new UserDataStandardScheme(); + } + } + + private static class UserDataStandardScheme extends StandardScheme<UserData> { + + public void read(org.apache.thrift.protocol.TProtocol iprot, UserData 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: // EMAIL + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.email = iprot.readString(); + struct.setEmailIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 3: // ROLE + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.role = iprot.readI32(); + struct.setRoleIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 4: // PERMISSION + if (schemeField.type == org.apache.thrift.protocol.TType.I32) { + struct.permission = iprot.readI32(); + struct.setPermissionIsSet(true); + } else { + org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); + } + break; + case 5: // TEMPLATE_NAME + if (schemeField.type == org.apache.thrift.protocol.TType.STRING) { + struct.templateName = iprot.readString(); + struct.setTemplateNameIsSet(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, UserData 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.email != null) { + oprot.writeFieldBegin(EMAIL_FIELD_DESC); + oprot.writeString(struct.email); + oprot.writeFieldEnd(); + } + oprot.writeFieldBegin(ROLE_FIELD_DESC); + oprot.writeI32(struct.role); + oprot.writeFieldEnd(); + oprot.writeFieldBegin(PERMISSION_FIELD_DESC); + oprot.writeI32(struct.permission); + oprot.writeFieldEnd(); + if (struct.templateName != null) { + oprot.writeFieldBegin(TEMPLATE_NAME_FIELD_DESC); + oprot.writeString(struct.templateName); + oprot.writeFieldEnd(); + } + oprot.writeFieldStop(); + oprot.writeStructEnd(); + } + + } + + private static class UserDataTupleSchemeFactory implements SchemeFactory { + public UserDataTupleScheme getScheme() { + return new UserDataTupleScheme(); + } + } + + private static class UserDataTupleScheme extends TupleScheme<UserData> { + + @Override + public void write(org.apache.thrift.protocol.TProtocol prot, UserData struct) throws org.apache.thrift.TException { + TTupleProtocol oprot = (TTupleProtocol) prot; + BitSet optionals = new BitSet(); + if (struct.isSetName()) { + optionals.set(0); + } + if (struct.isSetEmail()) { + optionals.set(1); + } + if (struct.isSetRole()) { + optionals.set(2); + } + if (struct.isSetPermission()) { + optionals.set(3); + } + if (struct.isSetTemplateName()) { + optionals.set(4); + } + oprot.writeBitSet(optionals, 5); + if (struct.isSetName()) { + oprot.writeString(struct.name); + } + if (struct.isSetEmail()) { + oprot.writeString(struct.email); + } + if (struct.isSetRole()) { + oprot.writeI32(struct.role); + } + if (struct.isSetPermission()) { + oprot.writeI32(struct.permission); + } + if (struct.isSetTemplateName()) { + oprot.writeString(struct.templateName); + } + } + + @Override + public void read(org.apache.thrift.protocol.TProtocol prot, UserData struct) throws org.apache.thrift.TException { + TTupleProtocol iprot = (TTupleProtocol) prot; + BitSet incoming = iprot.readBitSet(5); + if (incoming.get(0)) { + struct.name = iprot.readString(); + struct.setNameIsSet(true); + } + if (incoming.get(1)) { + struct.email = iprot.readString(); + struct.setEmailIsSet(true); + } + if (incoming.get(2)) { + struct.role = iprot.readI32(); + struct.setRoleIsSet(true); + } + if (incoming.get(3)) { + struct.permission = iprot.readI32(); + struct.setPermissionIsSet(true); + } + if (incoming.get(4)) { + struct.templateName = iprot.readString(); + struct.setTemplateNameIsSet(true); + } + } + } } diff --git a/app/src/main/res/menu/menu.xml b/app/src/main/res/menu/menu.xml index d24935a..70a6c66 100644 --- a/app/src/main/res/menu/menu.xml +++ b/app/src/main/res/menu/menu.xml @@ -32,4 +32,10 @@ android:icon="@drawable/ic_menu_restart" android:title="@string/restart_failed" /> + <item + android:id="@+id/ic_menu_check_captcha" + android:title="@string/check_captcha" + android:showAsAction="never" + android:checkable="true" /> + </menu> diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index a05245b..e9326c4 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -91,6 +91,7 @@ <string name="connect_error">Konnte keine Verbindung zu pyLoad herstellen. Bitte überprüfen sie, ob pyLoad läuft und ihre Servereinstellungen korrekt sind.</string> <string name="language">Sprache</string> <string name="language_desc">Sprache der App. Ein Neustart ist notwendig, damit die Änderungen in Kraft treten.</string> + <string name="check_captcha">Prüfe auf Captchas im Hintergrund</string> <string-array name="destination_list"> <item>Warteschlange</item> <item>Linksammler</item> diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 91ec5d2..7310d2b 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -102,6 +102,7 @@ </string> <string name="language">Language</string> <string name="language_desc">Language of the app. Needs a restart before changes take effect.</string> + <string name="check_captcha">Check Captchas in background</string> <string-array name="languages"> <item>Default</item> <item>English</item> diff --git a/build.gradle b/build.gradle index 1e90bc0..86ff169 100644 --- a/build.gradle +++ b/build.gradle @@ -5,7 +5,7 @@ buildscript { jcenter() } dependencies { - classpath 'com.android.tools.build:gradle:2.1.2' + classpath 'com.android.tools.build:gradle:2.2.2' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 0eeada9..bbdaaf9 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Fri Apr 08 13:28:48 CEST 2016 +#Wed Oct 19 21:15:38 BST 2016 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip