/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package test.fixtures.basic;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.BitSet;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.facebook.thrift.*;
import com.facebook.thrift.annotations.*;
import com.facebook.thrift.async.*;
import com.facebook.thrift.meta_data.*;
import com.facebook.thrift.server.*;
import com.facebook.thrift.transport.*;
import com.facebook.thrift.protocol.*;

@SuppressWarnings({ "unused", "serial" })
public class MyService {

  public interface Iface {

    public void ping() throws TException;

    public String getRandomData() throws TException;

    public void sink(Long sink) throws TException;

    public void putDataById(Long id, String data) throws TException;

    public Boolean hasDataById(Long id) throws TException;

    public String getDataById(Long id) throws TException;

    public void deleteDataById(Long id) throws TException;

    public void lobDataById(Long id, String data) throws TException;

    public Set<Float> invalid_return_for_hack() throws TException;

    public void rpc_skipped_codegen() throws TException;

  }

  public interface AsyncIface {

    public void ping(AsyncMethodCallback resultHandler) throws TException;

    public void getRandomData(AsyncMethodCallback resultHandler) throws TException;

    public void sink(Long sink, AsyncMethodCallback resultHandler) throws TException;

    public void putDataById(Long id, String data, AsyncMethodCallback resultHandler) throws TException;

    public void hasDataById(Long id, AsyncMethodCallback resultHandler) throws TException;

    public void getDataById(Long id, AsyncMethodCallback resultHandler) throws TException;

    public void deleteDataById(Long id, AsyncMethodCallback resultHandler) throws TException;

    public void lobDataById(Long id, String data, AsyncMethodCallback resultHandler) throws TException;

    public void invalid_return_for_hack(AsyncMethodCallback resultHandler) throws TException;

    public void rpc_skipped_codegen(AsyncMethodCallback resultHandler) throws TException;

  }

  public static class Client extends EventHandlerBase implements Iface, TClientIf {
    public Client(TProtocol prot)
    {
      this(prot, prot);
    }

    public Client(TProtocol iprot, TProtocol oprot)
    {
      iprot_ = iprot;
      oprot_ = oprot;
    }

    protected TProtocol iprot_;
    protected TProtocol oprot_;

    protected int seqid_;

    @Override
    public TProtocol getInputProtocol()
    {
      return this.iprot_;
    }

    @Override
    public TProtocol getOutputProtocol()
    {
      return this.oprot_;
    }

    public void ping() throws TException
    {
      ContextStack ctx = getContextStack("MyService.ping", null);
      this.setContextStack(ctx);
      send_ping();
      recv_ping();
    }

    public void send_ping() throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.ping", null);
      oprot_.writeMessageBegin(new TMessage("ping", TMessageType.CALL, seqid_));
      ping_args args = new ping_args();
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.ping", args);
      return;
    }

    public void recv_ping() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.ping");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      ping_result result = ping_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.ping", result);

      return;
    }

    public String getRandomData() throws TException
    {
      ContextStack ctx = getContextStack("MyService.getRandomData", null);
      this.setContextStack(ctx);
      send_getRandomData();
      return recv_getRandomData();
    }

    public void send_getRandomData() throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.getRandomData", null);
      oprot_.writeMessageBegin(new TMessage("getRandomData", TMessageType.CALL, seqid_));
      getRandomData_args args = new getRandomData_args();
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.getRandomData", args);
      return;
    }

    public String recv_getRandomData() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.getRandomData");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      getRandomData_result result = getRandomData_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.getRandomData", result);

      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getRandomData failed: unknown result");
    }

    public void sink(Long sink) throws TException
    {
      ContextStack ctx = getContextStack("MyService.sink", null);
      this.setContextStack(ctx);
      send_sink(sink);
      recv_sink();
    }

    public void send_sink(Long sink) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.sink", null);
      oprot_.writeMessageBegin(new TMessage("sink", TMessageType.CALL, seqid_));
      sink_args args = new sink_args();
      args.sink = sink;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.sink", args);
      return;
    }

    public void recv_sink() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.sink");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      sink_result result = sink_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.sink", result);

      return;
    }

    public void putDataById(Long id, String data) throws TException
    {
      ContextStack ctx = getContextStack("MyService.putDataById", null);
      this.setContextStack(ctx);
      send_putDataById(id, data);
      recv_putDataById();
    }

    public void send_putDataById(Long id, String data) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.putDataById", null);
      oprot_.writeMessageBegin(new TMessage("putDataById", TMessageType.CALL, seqid_));
      putDataById_args args = new putDataById_args();
      args.id = id;
      args.data = data;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.putDataById", args);
      return;
    }

    public void recv_putDataById() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.putDataById");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      putDataById_result result = putDataById_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.putDataById", result);

      return;
    }

    public Boolean hasDataById(Long id) throws TException
    {
      ContextStack ctx = getContextStack("MyService.hasDataById", null);
      this.setContextStack(ctx);
      send_hasDataById(id);
      return recv_hasDataById();
    }

    public void send_hasDataById(Long id) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.hasDataById", null);
      oprot_.writeMessageBegin(new TMessage("hasDataById", TMessageType.CALL, seqid_));
      hasDataById_args args = new hasDataById_args();
      args.id = id;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.hasDataById", args);
      return;
    }

    public Boolean recv_hasDataById() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.hasDataById");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      hasDataById_result result = hasDataById_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.hasDataById", result);

      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "hasDataById failed: unknown result");
    }

    public String getDataById(Long id) throws TException
    {
      ContextStack ctx = getContextStack("MyService.getDataById", null);
      this.setContextStack(ctx);
      send_getDataById(id);
      return recv_getDataById();
    }

    public void send_getDataById(Long id) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.getDataById", null);
      oprot_.writeMessageBegin(new TMessage("getDataById", TMessageType.CALL, seqid_));
      getDataById_args args = new getDataById_args();
      args.id = id;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.getDataById", args);
      return;
    }

    public String recv_getDataById() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.getDataById");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      getDataById_result result = getDataById_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.getDataById", result);

      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "getDataById failed: unknown result");
    }

    public void deleteDataById(Long id) throws TException
    {
      ContextStack ctx = getContextStack("MyService.deleteDataById", null);
      this.setContextStack(ctx);
      send_deleteDataById(id);
      recv_deleteDataById();
    }

    public void send_deleteDataById(Long id) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.deleteDataById", null);
      oprot_.writeMessageBegin(new TMessage("deleteDataById", TMessageType.CALL, seqid_));
      deleteDataById_args args = new deleteDataById_args();
      args.id = id;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.deleteDataById", args);
      return;
    }

    public void recv_deleteDataById() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.deleteDataById");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      deleteDataById_result result = deleteDataById_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.deleteDataById", result);

      return;
    }

    public void lobDataById(Long id, String data) throws TException
    {
      ContextStack ctx = getContextStack("MyService.lobDataById", null);
      this.setContextStack(ctx);
      send_lobDataById(id, data);
    }

    public void send_lobDataById(Long id, String data) throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.lobDataById", null);
      oprot_.writeMessageBegin(new TMessage("lobDataById", TMessageType.CALL, seqid_));
      lobDataById_args args = new lobDataById_args();
      args.id = id;
      args.data = data;
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().onewayFlush();
      super.postWrite(ctx, "MyService.lobDataById", args);
      return;
    }

    public Set<Float> invalid_return_for_hack() throws TException
    {
      ContextStack ctx = getContextStack("MyService.invalid_return_for_hack", null);
      this.setContextStack(ctx);
      send_invalid_return_for_hack();
      return recv_invalid_return_for_hack();
    }

    public void send_invalid_return_for_hack() throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.invalid_return_for_hack", null);
      oprot_.writeMessageBegin(new TMessage("invalid_return_for_hack", TMessageType.CALL, seqid_));
      invalid_return_for_hack_args args = new invalid_return_for_hack_args();
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.invalid_return_for_hack", args);
      return;
    }

    public Set<Float> recv_invalid_return_for_hack() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.invalid_return_for_hack");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      invalid_return_for_hack_result result = invalid_return_for_hack_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.invalid_return_for_hack", result);

      if (result.isSetSuccess()) {
        return result.success;
      }
      throw new TApplicationException(TApplicationException.MISSING_RESULT, "invalid_return_for_hack failed: unknown result");
    }

    public void rpc_skipped_codegen() throws TException
    {
      ContextStack ctx = getContextStack("MyService.rpc_skipped_codegen", null);
      this.setContextStack(ctx);
      send_rpc_skipped_codegen();
      recv_rpc_skipped_codegen();
    }

    public void send_rpc_skipped_codegen() throws TException
    {
      ContextStack ctx = this.getContextStack();
      super.preWrite(ctx, "MyService.rpc_skipped_codegen", null);
      oprot_.writeMessageBegin(new TMessage("rpc_skipped_codegen", TMessageType.CALL, seqid_));
      rpc_skipped_codegen_args args = new rpc_skipped_codegen_args();
      args.write(oprot_);
      oprot_.writeMessageEnd();
      oprot_.getTransport().flush();
      super.postWrite(ctx, "MyService.rpc_skipped_codegen", args);
      return;
    }

    public void recv_rpc_skipped_codegen() throws TException
    {
      ContextStack ctx = super.getContextStack();
      long bytes;
      TMessageType mtype;
      super.preRead(ctx, "MyService.rpc_skipped_codegen");
      TMessage msg = iprot_.readMessageBegin();
      if (msg.type == TMessageType.EXCEPTION) {
        TApplicationException x = TApplicationException.read(iprot_);
        iprot_.readMessageEnd();
        throw x;
      }
      rpc_skipped_codegen_result result = rpc_skipped_codegen_result.deserialize(iprot_);
      iprot_.readMessageEnd();
      super.postRead(ctx, "MyService.rpc_skipped_codegen", result);

      return;
    }

  }
  public static class AsyncClient extends TAsyncClient implements AsyncIface {
    public static class Factory implements TAsyncClientFactory<AsyncClient> {
      private TAsyncClientManager clientManager;
      private TProtocolFactory protocolFactory;
      public Factory(TAsyncClientManager clientManager, TProtocolFactory protocolFactory) {
        this.clientManager = clientManager;
        this.protocolFactory = protocolFactory;
      }
      public AsyncClient getAsyncClient(TNonblockingTransport transport) {
        return new AsyncClient(protocolFactory, clientManager, transport);
      }
    }

    public AsyncClient(TProtocolFactory protocolFactory, TAsyncClientManager clientManager, TNonblockingTransport transport) {
      super(protocolFactory, clientManager, transport);
    }

    public void ping(AsyncMethodCallback resultHandler48) throws TException {
      checkReady();
      ping_call method_call = new ping_call(resultHandler48, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class ping_call extends TAsyncMethodCall {
      public ping_call(AsyncMethodCallback resultHandler49, TAsyncClient client45, TProtocolFactory protocolFactory46, TNonblockingTransport transport47) throws TException {
        super(client45, protocolFactory46, transport47, resultHandler49, false);
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("ping", TMessageType.CALL, 0));
        ping_args args = new ping_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_ping();
      }
    }

    public void getRandomData(AsyncMethodCallback resultHandler53) throws TException {
      checkReady();
      getRandomData_call method_call = new getRandomData_call(resultHandler53, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getRandomData_call extends TAsyncMethodCall {
      public getRandomData_call(AsyncMethodCallback resultHandler54, TAsyncClient client50, TProtocolFactory protocolFactory51, TNonblockingTransport transport52) throws TException {
        super(client50, protocolFactory51, transport52, resultHandler54, false);
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("getRandomData", TMessageType.CALL, 0));
        getRandomData_args args = new getRandomData_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public String getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getRandomData();
      }
    }

    public void sink(Long sink, AsyncMethodCallback resultHandler58) throws TException {
      checkReady();
      sink_call method_call = new sink_call(sink, resultHandler58, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class sink_call extends TAsyncMethodCall {
      private Long sink;
      public sink_call(Long sink, AsyncMethodCallback resultHandler59, TAsyncClient client55, TProtocolFactory protocolFactory56, TNonblockingTransport transport57) throws TException {
        super(client55, protocolFactory56, transport57, resultHandler59, false);
        this.sink = sink;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("sink", TMessageType.CALL, 0));
        sink_args args = new sink_args();
        args.setSink(sink);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_sink();
      }
    }

    public void putDataById(Long id, String data, AsyncMethodCallback resultHandler63) throws TException {
      checkReady();
      putDataById_call method_call = new putDataById_call(id, data, resultHandler63, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class putDataById_call extends TAsyncMethodCall {
      private Long id;
      private String data;
      public putDataById_call(Long id, String data, AsyncMethodCallback resultHandler64, TAsyncClient client60, TProtocolFactory protocolFactory61, TNonblockingTransport transport62) throws TException {
        super(client60, protocolFactory61, transport62, resultHandler64, false);
        this.id = id;
        this.data = data;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("putDataById", TMessageType.CALL, 0));
        putDataById_args args = new putDataById_args();
        args.setId(id);
        args.setData(data);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_putDataById();
      }
    }

    public void hasDataById(Long id, AsyncMethodCallback resultHandler68) throws TException {
      checkReady();
      hasDataById_call method_call = new hasDataById_call(id, resultHandler68, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class hasDataById_call extends TAsyncMethodCall {
      private Long id;
      public hasDataById_call(Long id, AsyncMethodCallback resultHandler69, TAsyncClient client65, TProtocolFactory protocolFactory66, TNonblockingTransport transport67) throws TException {
        super(client65, protocolFactory66, transport67, resultHandler69, false);
        this.id = id;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("hasDataById", TMessageType.CALL, 0));
        hasDataById_args args = new hasDataById_args();
        args.setId(id);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public Boolean getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_hasDataById();
      }
    }

    public void getDataById(Long id, AsyncMethodCallback resultHandler73) throws TException {
      checkReady();
      getDataById_call method_call = new getDataById_call(id, resultHandler73, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class getDataById_call extends TAsyncMethodCall {
      private Long id;
      public getDataById_call(Long id, AsyncMethodCallback resultHandler74, TAsyncClient client70, TProtocolFactory protocolFactory71, TNonblockingTransport transport72) throws TException {
        super(client70, protocolFactory71, transport72, resultHandler74, false);
        this.id = id;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("getDataById", TMessageType.CALL, 0));
        getDataById_args args = new getDataById_args();
        args.setId(id);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public String getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_getDataById();
      }
    }

    public void deleteDataById(Long id, AsyncMethodCallback resultHandler78) throws TException {
      checkReady();
      deleteDataById_call method_call = new deleteDataById_call(id, resultHandler78, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class deleteDataById_call extends TAsyncMethodCall {
      private Long id;
      public deleteDataById_call(Long id, AsyncMethodCallback resultHandler79, TAsyncClient client75, TProtocolFactory protocolFactory76, TNonblockingTransport transport77) throws TException {
        super(client75, protocolFactory76, transport77, resultHandler79, false);
        this.id = id;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("deleteDataById", TMessageType.CALL, 0));
        deleteDataById_args args = new deleteDataById_args();
        args.setId(id);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_deleteDataById();
      }
    }

    public void lobDataById(Long id, String data, AsyncMethodCallback resultHandler83) throws TException {
      checkReady();
      lobDataById_call method_call = new lobDataById_call(id, data, resultHandler83, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class lobDataById_call extends TAsyncMethodCall {
      private Long id;
      private String data;
      public lobDataById_call(Long id, String data, AsyncMethodCallback resultHandler84, TAsyncClient client80, TProtocolFactory protocolFactory81, TNonblockingTransport transport82) throws TException {
        super(client80, protocolFactory81, transport82, resultHandler84, true);
        this.id = id;
        this.data = data;
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("lobDataById", TMessageType.CALL, 0));
        lobDataById_args args = new lobDataById_args();
        args.setId(id);
        args.setData(data);
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
      }
    }

    public void invalid_return_for_hack(AsyncMethodCallback resultHandler88) throws TException {
      checkReady();
      invalid_return_for_hack_call method_call = new invalid_return_for_hack_call(resultHandler88, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class invalid_return_for_hack_call extends TAsyncMethodCall {
      public invalid_return_for_hack_call(AsyncMethodCallback resultHandler89, TAsyncClient client85, TProtocolFactory protocolFactory86, TNonblockingTransport transport87) throws TException {
        super(client85, protocolFactory86, transport87, resultHandler89, false);
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("invalid_return_for_hack", TMessageType.CALL, 0));
        invalid_return_for_hack_args args = new invalid_return_for_hack_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public Set<Float> getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        return (new Client(prot)).recv_invalid_return_for_hack();
      }
    }

    public void rpc_skipped_codegen(AsyncMethodCallback resultHandler93) throws TException {
      checkReady();
      rpc_skipped_codegen_call method_call = new rpc_skipped_codegen_call(resultHandler93, this, ___protocolFactory, ___transport);
      this.___currentMethod = method_call;
      ___manager.call(method_call);
    }

    public static class rpc_skipped_codegen_call extends TAsyncMethodCall {
      public rpc_skipped_codegen_call(AsyncMethodCallback resultHandler94, TAsyncClient client90, TProtocolFactory protocolFactory91, TNonblockingTransport transport92) throws TException {
        super(client90, protocolFactory91, transport92, resultHandler94, false);
      }

      public void write_args(TProtocol prot) throws TException {
        prot.writeMessageBegin(new TMessage("rpc_skipped_codegen", TMessageType.CALL, 0));
        rpc_skipped_codegen_args args = new rpc_skipped_codegen_args();
        args.write(prot);
        prot.writeMessageEnd();
      }

      public void getResult() throws TException {
        if (getState() != State.RESPONSE_READ) {
          throw new IllegalStateException("Method call not finished!");
        }
        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
        TProtocol prot = super.client.getProtocolFactory().getProtocol(memoryTransport);
        (new Client(prot)).recv_rpc_skipped_codegen();
      }
    }

  }

  public static class Processor implements TProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(Processor.class.getName());
    public Processor(Iface iface)
    {
      iface_ = iface;
      event_handler_ = new TProcessorEventHandler(); // Empty handler
      processMap_.put("ping", new ping());
      processMap_.put("getRandomData", new getRandomData());
      processMap_.put("sink", new sink());
      processMap_.put("putDataById", new putDataById());
      processMap_.put("hasDataById", new hasDataById());
      processMap_.put("getDataById", new getDataById());
      processMap_.put("deleteDataById", new deleteDataById());
      processMap_.put("lobDataById", new lobDataById());
      processMap_.put("invalid_return_for_hack", new invalid_return_for_hack());
      processMap_.put("rpc_skipped_codegen", new rpc_skipped_codegen());
    }

    protected static interface ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException;
    }

    public void setEventHandler(TProcessorEventHandler handler) {
      this.event_handler_ = handler;
    }

    private Iface iface_;
    protected TProcessorEventHandler event_handler_;
    protected final HashMap<String,ProcessFunction> processMap_ = new HashMap<String,ProcessFunction>();

    public boolean process(TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
    {
      TMessage msg = iprot.readMessageBegin();
      ProcessFunction fn = processMap_.get(msg.name);
      if (fn == null) {
        TProtocolUtil.skip(iprot, TType.STRUCT);
        iprot.readMessageEnd();
        TApplicationException x = new TApplicationException(TApplicationException.UNKNOWN_METHOD, "Invalid method name: '"+msg.name+"'");
        oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));
        x.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        return true;
      }
      fn.process(msg.seqid, iprot, oprot, server_ctx);
      return true;
    }

    private class ping implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.ping", server_ctx);
        ping_args args = new ping_args();
        event_handler_.preRead(handler_ctx, "MyService.ping");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.ping", args);
        ping_result result = new ping_result();
        iface_.ping();
        event_handler_.preWrite(handler_ctx, "MyService.ping", result);
        oprot.writeMessageBegin(new TMessage("ping", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.ping", result);
      }

    }

    private class getRandomData implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.getRandomData", server_ctx);
        getRandomData_args args = new getRandomData_args();
        event_handler_.preRead(handler_ctx, "MyService.getRandomData");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.getRandomData", args);
        getRandomData_result result = new getRandomData_result();
        result.success = iface_.getRandomData();
        event_handler_.preWrite(handler_ctx, "MyService.getRandomData", result);
        oprot.writeMessageBegin(new TMessage("getRandomData", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.getRandomData", result);
      }

    }

    private class sink implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.sink", server_ctx);
        sink_args args = new sink_args();
        event_handler_.preRead(handler_ctx, "MyService.sink");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.sink", args);
        sink_result result = new sink_result();
        iface_.sink(args.sink);
        event_handler_.preWrite(handler_ctx, "MyService.sink", result);
        oprot.writeMessageBegin(new TMessage("sink", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.sink", result);
      }

    }

    private class putDataById implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.putDataById", server_ctx);
        putDataById_args args = new putDataById_args();
        event_handler_.preRead(handler_ctx, "MyService.putDataById");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.putDataById", args);
        putDataById_result result = new putDataById_result();
        iface_.putDataById(args.id, args.data);
        event_handler_.preWrite(handler_ctx, "MyService.putDataById", result);
        oprot.writeMessageBegin(new TMessage("putDataById", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.putDataById", result);
      }

    }

    private class hasDataById implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.hasDataById", server_ctx);
        hasDataById_args args = new hasDataById_args();
        event_handler_.preRead(handler_ctx, "MyService.hasDataById");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.hasDataById", args);
        hasDataById_result result = new hasDataById_result();
        result.success = iface_.hasDataById(args.id);
        event_handler_.preWrite(handler_ctx, "MyService.hasDataById", result);
        oprot.writeMessageBegin(new TMessage("hasDataById", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.hasDataById", result);
      }

    }

    private class getDataById implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.getDataById", server_ctx);
        getDataById_args args = new getDataById_args();
        event_handler_.preRead(handler_ctx, "MyService.getDataById");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.getDataById", args);
        getDataById_result result = new getDataById_result();
        result.success = iface_.getDataById(args.id);
        event_handler_.preWrite(handler_ctx, "MyService.getDataById", result);
        oprot.writeMessageBegin(new TMessage("getDataById", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.getDataById", result);
      }

    }

    private class deleteDataById implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.deleteDataById", server_ctx);
        deleteDataById_args args = new deleteDataById_args();
        event_handler_.preRead(handler_ctx, "MyService.deleteDataById");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.deleteDataById", args);
        deleteDataById_result result = new deleteDataById_result();
        iface_.deleteDataById(args.id);
        event_handler_.preWrite(handler_ctx, "MyService.deleteDataById", result);
        oprot.writeMessageBegin(new TMessage("deleteDataById", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.deleteDataById", result);
      }

    }

    private class lobDataById implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.lobDataById", server_ctx);
        lobDataById_args args = new lobDataById_args();
        event_handler_.preRead(handler_ctx, "MyService.lobDataById");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.lobDataById", args);
        iface_.lobDataById(args.id, args.data);
        return;
      }
    }

    private class invalid_return_for_hack implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.invalid_return_for_hack", server_ctx);
        invalid_return_for_hack_args args = new invalid_return_for_hack_args();
        event_handler_.preRead(handler_ctx, "MyService.invalid_return_for_hack");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.invalid_return_for_hack", args);
        invalid_return_for_hack_result result = new invalid_return_for_hack_result();
        result.success = iface_.invalid_return_for_hack();
        event_handler_.preWrite(handler_ctx, "MyService.invalid_return_for_hack", result);
        oprot.writeMessageBegin(new TMessage("invalid_return_for_hack", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.invalid_return_for_hack", result);
      }

    }

    private class rpc_skipped_codegen implements ProcessFunction {
      public void process(int seqid, TProtocol iprot, TProtocol oprot, TConnectionContext server_ctx) throws TException
      {
        Object handler_ctx = event_handler_.getContext("MyService.rpc_skipped_codegen", server_ctx);
        rpc_skipped_codegen_args args = new rpc_skipped_codegen_args();
        event_handler_.preRead(handler_ctx, "MyService.rpc_skipped_codegen");
        args.read(iprot);
        iprot.readMessageEnd();
        event_handler_.postRead(handler_ctx, "MyService.rpc_skipped_codegen", args);
        rpc_skipped_codegen_result result = new rpc_skipped_codegen_result();
        iface_.rpc_skipped_codegen();
        event_handler_.preWrite(handler_ctx, "MyService.rpc_skipped_codegen", result);
        oprot.writeMessageBegin(new TMessage("rpc_skipped_codegen", TMessageType.REPLY, seqid));
        result.write(oprot);
        oprot.writeMessageEnd();
        oprot.getTransport().flush();
        event_handler_.postWrite(handler_ctx, "MyService.rpc_skipped_codegen", result);
      }

    }

  }

  public static class ping_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("ping_args");


    public ping_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public ping_args(ping_args other) {
    }

    public ping_args deepCopy() {
      return new ping_args(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof ping_args))
        return false;
      ping_args that = (ping_args)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static ping_args deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      ping_args _that;
      _that = new ping_args(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class ping_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("ping_result");


    public ping_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public ping_result(ping_result other) {
    }

    public ping_result deepCopy() {
      return new ping_result(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof ping_result))
        return false;
      ping_result that = (ping_result)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static ping_result deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      ping_result _that;
      _that = new ping_result(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class getRandomData_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getRandomData_args");


    public getRandomData_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getRandomData_args(getRandomData_args other) {
    }

    public getRandomData_args deepCopy() {
      return new getRandomData_args(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof getRandomData_args))
        return false;
      getRandomData_args that = (getRandomData_args)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static getRandomData_args deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      getRandomData_args _that;
      _that = new getRandomData_args(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class getRandomData_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getRandomData_result");
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short)0);

    public String success;
    public static final int SUCCESS = 0;

    // isset id assignments


    public getRandomData_result() {
    }

    public getRandomData_result(
        String success) {
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getRandomData_result(getRandomData_result other) {
      if (other.isSetSuccess()) {
        this.success = TBaseHelper.deepCopy(other.success);
      }
    }

    public getRandomData_result deepCopy() {
      return new getRandomData_result(this);
    }

    public String getSuccess() {
      return this.success;
    }

    public getRandomData_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;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof getRandomData_result))
        return false;
      getRandomData_result that = (getRandomData_result)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetSuccess(), that.isSetSuccess(), this.success, that.success)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {success});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static getRandomData_result deserialize(TProtocol iprot) throws TException {
      String tmp_success = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case SUCCESS:
            if (__field.type == TType.STRING) {
              tmp_success = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      getRandomData_result _that;
      _that = new getRandomData_result(
        tmp_success
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        oprot.writeString(this.success);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class sink_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("sink_args");
    private static final TField SINK_FIELD_DESC = new TField("sink", TType.I64, (short)1);

    public Long sink;
    public static final int SINK = 1;

    // isset id assignments


    public sink_args() {
    }

    public sink_args(
        Long sink) {
      this.sink = sink;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public sink_args(sink_args other) {
      if (other.isSetSink()) {
        this.sink = TBaseHelper.deepCopy(other.sink);
      }
    }

    public sink_args deepCopy() {
      return new sink_args(this);
    }

    public Long getSink() {
      return this.sink;
    }

    public sink_args setSink(Long sink) {
      this.sink = sink;
      return this;
    }

    public void unsetSink() {
      this.sink = null;
    }

    // Returns true if field sink is set (has been assigned a value) and false otherwise
    public boolean isSetSink() {
      return this.sink != null;
    }

    public void setSinkIsSet(boolean __value) {
      if (!__value) {
        this.sink = null;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof sink_args))
        return false;
      sink_args that = (sink_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetSink(), that.isSetSink(), this.sink, that.sink)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {sink});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static sink_args deserialize(TProtocol iprot) throws TException {
      Long tmp_sink = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case SINK:
            if (__field.type == TType.I64) {
              tmp_sink = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      sink_args _that;
      _that = new sink_args(
        tmp_sink
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.sink != null) {
        oprot.writeFieldBegin(SINK_FIELD_DESC);
        oprot.writeI64(this.sink);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class sink_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("sink_result");


    public sink_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public sink_result(sink_result other) {
    }

    public sink_result deepCopy() {
      return new sink_result(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof sink_result))
        return false;
      sink_result that = (sink_result)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static sink_result deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      sink_result _that;
      _that = new sink_result(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class putDataById_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("putDataById_args");
    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
    private static final TField DATA_FIELD_DESC = new TField("data", TType.STRING, (short)2);

    public Long id;
    public String data;
    public static final int ID = 1;
    public static final int DATA = 2;

    // isset id assignments


    public putDataById_args() {
    }

    public putDataById_args(
        Long id,
        String data) {
      this.id = id;
      this.data = data;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public putDataById_args(putDataById_args other) {
      if (other.isSetId()) {
        this.id = TBaseHelper.deepCopy(other.id);
      }
      if (other.isSetData()) {
        this.data = TBaseHelper.deepCopy(other.data);
      }
    }

    public putDataById_args deepCopy() {
      return new putDataById_args(this);
    }

    public Long getId() {
      return this.id;
    }

    public putDataById_args setId(Long id) {
      this.id = id;
      return this;
    }

    public void unsetId() {
      this.id = null;
    }

    // Returns true if field id is set (has been assigned a value) and false otherwise
    public boolean isSetId() {
      return this.id != null;
    }

    public void setIdIsSet(boolean __value) {
      if (!__value) {
        this.id = null;
      }
    }

    public String getData() {
      return this.data;
    }

    public putDataById_args setData(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;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof putDataById_args))
        return false;
      putDataById_args that = (putDataById_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetId(), that.isSetId(), this.id, that.id)) { return false; }

      if (!TBaseHelper.equalsNobinary(this.isSetData(), that.isSetData(), this.data, that.data)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {id, data});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static putDataById_args deserialize(TProtocol iprot) throws TException {
      Long tmp_id = null;
      String tmp_data = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case ID:
            if (__field.type == TType.I64) {
              tmp_id = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          case DATA:
            if (__field.type == TType.STRING) {
              tmp_data = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      putDataById_args _that;
      _that = new putDataById_args(
        tmp_id
        ,tmp_data
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.id != null) {
        oprot.writeFieldBegin(ID_FIELD_DESC);
        oprot.writeI64(this.id);
        oprot.writeFieldEnd();
      }
      if (this.data != null) {
        oprot.writeFieldBegin(DATA_FIELD_DESC);
        oprot.writeString(this.data);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class putDataById_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("putDataById_result");


    public putDataById_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public putDataById_result(putDataById_result other) {
    }

    public putDataById_result deepCopy() {
      return new putDataById_result(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof putDataById_result))
        return false;
      putDataById_result that = (putDataById_result)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static putDataById_result deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      putDataById_result _that;
      _that = new putDataById_result(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class hasDataById_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("hasDataById_args");
    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);

    public Long id;
    public static final int ID = 1;

    // isset id assignments


    public hasDataById_args() {
    }

    public hasDataById_args(
        Long id) {
      this.id = id;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public hasDataById_args(hasDataById_args other) {
      if (other.isSetId()) {
        this.id = TBaseHelper.deepCopy(other.id);
      }
    }

    public hasDataById_args deepCopy() {
      return new hasDataById_args(this);
    }

    public Long getId() {
      return this.id;
    }

    public hasDataById_args setId(Long id) {
      this.id = id;
      return this;
    }

    public void unsetId() {
      this.id = null;
    }

    // Returns true if field id is set (has been assigned a value) and false otherwise
    public boolean isSetId() {
      return this.id != null;
    }

    public void setIdIsSet(boolean __value) {
      if (!__value) {
        this.id = null;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof hasDataById_args))
        return false;
      hasDataById_args that = (hasDataById_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetId(), that.isSetId(), this.id, that.id)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {id});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static hasDataById_args deserialize(TProtocol iprot) throws TException {
      Long tmp_id = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case ID:
            if (__field.type == TType.I64) {
              tmp_id = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      hasDataById_args _that;
      _that = new hasDataById_args(
        tmp_id
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.id != null) {
        oprot.writeFieldBegin(ID_FIELD_DESC);
        oprot.writeI64(this.id);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class hasDataById_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("hasDataById_result");
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.BOOL, (short)0);

    public Boolean success;
    public static final int SUCCESS = 0;

    // isset id assignments


    public hasDataById_result() {
    }

    public hasDataById_result(
        Boolean success) {
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public hasDataById_result(hasDataById_result other) {
      if (other.isSetSuccess()) {
        this.success = TBaseHelper.deepCopy(other.success);
      }
    }

    public hasDataById_result deepCopy() {
      return new hasDataById_result(this);
    }

    public Boolean isSuccess() {
      return this.success;
    }

    public hasDataById_result setSuccess(Boolean success) {
      this.success = success;
      return this;
    }

    public void unsetSuccess() {
      this.success = null;
    }

    // Returns true if field success is set (has been assigned a value) and false otherwise
    public boolean isSetSuccess() {
      return this.success != null;
    }

    public void setSuccessIsSet(boolean __value) {
      if (!__value) {
        this.success = null;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof hasDataById_result))
        return false;
      hasDataById_result that = (hasDataById_result)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetSuccess(), that.isSetSuccess(), this.success, that.success)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {success});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static hasDataById_result deserialize(TProtocol iprot) throws TException {
      Boolean tmp_success = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case SUCCESS:
            if (__field.type == TType.BOOL) {
              tmp_success = iprot.readBool();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      hasDataById_result _that;
      _that = new hasDataById_result(
        tmp_success
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        oprot.writeBool(this.success);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class getDataById_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getDataById_args");
    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);

    public Long id;
    public static final int ID = 1;

    // isset id assignments


    public getDataById_args() {
    }

    public getDataById_args(
        Long id) {
      this.id = id;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getDataById_args(getDataById_args other) {
      if (other.isSetId()) {
        this.id = TBaseHelper.deepCopy(other.id);
      }
    }

    public getDataById_args deepCopy() {
      return new getDataById_args(this);
    }

    public Long getId() {
      return this.id;
    }

    public getDataById_args setId(Long id) {
      this.id = id;
      return this;
    }

    public void unsetId() {
      this.id = null;
    }

    // Returns true if field id is set (has been assigned a value) and false otherwise
    public boolean isSetId() {
      return this.id != null;
    }

    public void setIdIsSet(boolean __value) {
      if (!__value) {
        this.id = null;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof getDataById_args))
        return false;
      getDataById_args that = (getDataById_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetId(), that.isSetId(), this.id, that.id)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {id});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static getDataById_args deserialize(TProtocol iprot) throws TException {
      Long tmp_id = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case ID:
            if (__field.type == TType.I64) {
              tmp_id = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      getDataById_args _that;
      _that = new getDataById_args(
        tmp_id
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.id != null) {
        oprot.writeFieldBegin(ID_FIELD_DESC);
        oprot.writeI64(this.id);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class getDataById_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("getDataById_result");
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.STRING, (short)0);

    public String success;
    public static final int SUCCESS = 0;

    // isset id assignments


    public getDataById_result() {
    }

    public getDataById_result(
        String success) {
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public getDataById_result(getDataById_result other) {
      if (other.isSetSuccess()) {
        this.success = TBaseHelper.deepCopy(other.success);
      }
    }

    public getDataById_result deepCopy() {
      return new getDataById_result(this);
    }

    public String getSuccess() {
      return this.success;
    }

    public getDataById_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;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof getDataById_result))
        return false;
      getDataById_result that = (getDataById_result)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetSuccess(), that.isSetSuccess(), this.success, that.success)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {success});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static getDataById_result deserialize(TProtocol iprot) throws TException {
      String tmp_success = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case SUCCESS:
            if (__field.type == TType.STRING) {
              tmp_success = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      getDataById_result _that;
      _that = new getDataById_result(
        tmp_success
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        oprot.writeString(this.success);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class deleteDataById_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("deleteDataById_args");
    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);

    public Long id;
    public static final int ID = 1;

    // isset id assignments


    public deleteDataById_args() {
    }

    public deleteDataById_args(
        Long id) {
      this.id = id;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteDataById_args(deleteDataById_args other) {
      if (other.isSetId()) {
        this.id = TBaseHelper.deepCopy(other.id);
      }
    }

    public deleteDataById_args deepCopy() {
      return new deleteDataById_args(this);
    }

    public Long getId() {
      return this.id;
    }

    public deleteDataById_args setId(Long id) {
      this.id = id;
      return this;
    }

    public void unsetId() {
      this.id = null;
    }

    // Returns true if field id is set (has been assigned a value) and false otherwise
    public boolean isSetId() {
      return this.id != null;
    }

    public void setIdIsSet(boolean __value) {
      if (!__value) {
        this.id = null;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof deleteDataById_args))
        return false;
      deleteDataById_args that = (deleteDataById_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetId(), that.isSetId(), this.id, that.id)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {id});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static deleteDataById_args deserialize(TProtocol iprot) throws TException {
      Long tmp_id = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case ID:
            if (__field.type == TType.I64) {
              tmp_id = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      deleteDataById_args _that;
      _that = new deleteDataById_args(
        tmp_id
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.id != null) {
        oprot.writeFieldBegin(ID_FIELD_DESC);
        oprot.writeI64(this.id);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class deleteDataById_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("deleteDataById_result");


    public deleteDataById_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public deleteDataById_result(deleteDataById_result other) {
    }

    public deleteDataById_result deepCopy() {
      return new deleteDataById_result(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof deleteDataById_result))
        return false;
      deleteDataById_result that = (deleteDataById_result)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static deleteDataById_result deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      deleteDataById_result _that;
      _that = new deleteDataById_result(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class lobDataById_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("lobDataById_args");
    private static final TField ID_FIELD_DESC = new TField("id", TType.I64, (short)1);
    private static final TField DATA_FIELD_DESC = new TField("data", TType.STRING, (short)2);

    public Long id;
    public String data;
    public static final int ID = 1;
    public static final int DATA = 2;

    // isset id assignments


    public lobDataById_args() {
    }

    public lobDataById_args(
        Long id,
        String data) {
      this.id = id;
      this.data = data;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public lobDataById_args(lobDataById_args other) {
      if (other.isSetId()) {
        this.id = TBaseHelper.deepCopy(other.id);
      }
      if (other.isSetData()) {
        this.data = TBaseHelper.deepCopy(other.data);
      }
    }

    public lobDataById_args deepCopy() {
      return new lobDataById_args(this);
    }

    public Long getId() {
      return this.id;
    }

    public lobDataById_args setId(Long id) {
      this.id = id;
      return this;
    }

    public void unsetId() {
      this.id = null;
    }

    // Returns true if field id is set (has been assigned a value) and false otherwise
    public boolean isSetId() {
      return this.id != null;
    }

    public void setIdIsSet(boolean __value) {
      if (!__value) {
        this.id = null;
      }
    }

    public String getData() {
      return this.data;
    }

    public lobDataById_args setData(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;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof lobDataById_args))
        return false;
      lobDataById_args that = (lobDataById_args)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetId(), that.isSetId(), this.id, that.id)) { return false; }

      if (!TBaseHelper.equalsNobinary(this.isSetData(), that.isSetData(), this.data, that.data)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {id, data});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static lobDataById_args deserialize(TProtocol iprot) throws TException {
      Long tmp_id = null;
      String tmp_data = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case ID:
            if (__field.type == TType.I64) {
              tmp_id = iprot.readI64();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          case DATA:
            if (__field.type == TType.STRING) {
              tmp_data = iprot.readString();
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      lobDataById_args _that;
      _that = new lobDataById_args(
        tmp_id
        ,tmp_data
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      if (this.id != null) {
        oprot.writeFieldBegin(ID_FIELD_DESC);
        oprot.writeI64(this.id);
        oprot.writeFieldEnd();
      }
      if (this.data != null) {
        oprot.writeFieldBegin(DATA_FIELD_DESC);
        oprot.writeString(this.data);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class invalid_return_for_hack_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("invalid_return_for_hack_args");


    public invalid_return_for_hack_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public invalid_return_for_hack_args(invalid_return_for_hack_args other) {
    }

    public invalid_return_for_hack_args deepCopy() {
      return new invalid_return_for_hack_args(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof invalid_return_for_hack_args))
        return false;
      invalid_return_for_hack_args that = (invalid_return_for_hack_args)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static invalid_return_for_hack_args deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      invalid_return_for_hack_args _that;
      _that = new invalid_return_for_hack_args(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class invalid_return_for_hack_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("invalid_return_for_hack_result");
    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.SET, (short)0);

    public Set<Float> success;
    public static final int SUCCESS = 0;

    // isset id assignments


    public invalid_return_for_hack_result() {
    }

    public invalid_return_for_hack_result(
        Set<Float> success) {
      this.success = success;
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public invalid_return_for_hack_result(invalid_return_for_hack_result other) {
      if (other.isSetSuccess()) {
        this.success = TBaseHelper.deepCopy(other.success);
      }
    }

    public invalid_return_for_hack_result deepCopy() {
      return new invalid_return_for_hack_result(this);
    }

    public Set<Float> getSuccess() {
      return this.success;
    }

    public invalid_return_for_hack_result setSuccess(Set<Float> 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;
      }
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof invalid_return_for_hack_result))
        return false;
      invalid_return_for_hack_result that = (invalid_return_for_hack_result)_that;

      if (!TBaseHelper.equalsNobinary(this.isSetSuccess(), that.isSetSuccess(), this.success, that.success)) { return false; }

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {success});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static invalid_return_for_hack_result deserialize(TProtocol iprot) throws TException {
      Set<Float> tmp_success = null;
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          case SUCCESS:
            if (__field.type == TType.SET) {
              {
                TSet _set95 = iprot.readSetBegin();
                tmp_success = new HashSet<Float>(Math.max(0, 2*_set95.size));
                for (int _i96 = 0; 
                     (_set95.size < 0) ? iprot.peekSet() : (_i96 < _set95.size); 
                     ++_i96)
                {
                  Float _elem97;
                  _elem97 = iprot.readFloat();
                  tmp_success.add(_elem97);
                }
                iprot.readSetEnd();
              }
            } else {
              TProtocolUtil.skip(iprot, __field.type);
            }
            break;
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      invalid_return_for_hack_result _that;
      _that = new invalid_return_for_hack_result(
        tmp_success
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      if (this.isSetSuccess()) {
        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
        {
          oprot.writeSetBegin(new TSet(TType.FLOAT, this.success.size()));
          for (Float _iter98 : this.success)          {
            oprot.writeFloat(_iter98);
          }
          oprot.writeSetEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class rpc_skipped_codegen_args implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("rpc_skipped_codegen_args");


    public rpc_skipped_codegen_args() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public rpc_skipped_codegen_args(rpc_skipped_codegen_args other) {
    }

    public rpc_skipped_codegen_args deepCopy() {
      return new rpc_skipped_codegen_args(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof rpc_skipped_codegen_args))
        return false;
      rpc_skipped_codegen_args that = (rpc_skipped_codegen_args)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static rpc_skipped_codegen_args deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      rpc_skipped_codegen_args _that;
      _that = new rpc_skipped_codegen_args(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

  public static class rpc_skipped_codegen_result implements TBase, java.io.Serializable, Cloneable   {
    private static final TStruct STRUCT_DESC = new TStruct("rpc_skipped_codegen_result");


    public rpc_skipped_codegen_result() {
    }

    /**
     * Performs a deep copy on <i>other</i>.
     */
    public rpc_skipped_codegen_result(rpc_skipped_codegen_result other) {
    }

    public rpc_skipped_codegen_result deepCopy() {
      return new rpc_skipped_codegen_result(this);
    }

    @Override
    public boolean equals(Object _that) {
      if (_that == null)
        return false;
      if (this == _that)
        return true;
      if (!(_that instanceof rpc_skipped_codegen_result))
        return false;
      rpc_skipped_codegen_result that = (rpc_skipped_codegen_result)_that;

      return true;
    }

    @Override
    public int hashCode() {
      return Arrays.deepHashCode(new Object[] {});
    }

    // This is required to satisfy the TBase interface, but can't be implemented on immutable struture.
    public void read(TProtocol iprot) throws TException {
      throw new TException("unimplemented in android immutable structure");
    }

    public static rpc_skipped_codegen_result deserialize(TProtocol iprot) throws TException {
      TField __field;
      iprot.readStructBegin();
      while (true)
      {
        __field = iprot.readFieldBegin();
        if (__field.type == TType.STOP) {
          break;
        }
        switch (__field.id)
        {
          default:
            TProtocolUtil.skip(iprot, __field.type);
            break;
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

      rpc_skipped_codegen_result _that;
      _that = new rpc_skipped_codegen_result(
      );
      _that.validate();
      return _that;
    }

    public void write(TProtocol oprot) throws TException {
      oprot.writeStructBegin(STRUCT_DESC);

      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

    @Override
    public String toString() {
      return toString(1, true);
    }

    @Override
    public String toString(int indent, boolean prettyPrint) {
      return TBaseHelper.toStringHelper(this, indent, prettyPrint);
    }

    public void validate() throws TException {
      // check for required fields
    }

  }

}
