1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 package org.waarp.thrift.r66;
27
28 import org.apache.thrift.EncodingUtils;
29 import org.apache.thrift.ProcessFunction;
30 import org.apache.thrift.TApplicationException;
31 import org.apache.thrift.TBase;
32 import org.apache.thrift.TBaseHelper;
33 import org.apache.thrift.TBaseProcessor;
34 import org.apache.thrift.TException;
35 import org.apache.thrift.TFieldIdEnum;
36 import org.apache.thrift.TFieldRequirementType;
37 import org.apache.thrift.TServiceClient;
38 import org.apache.thrift.TServiceClientFactory;
39 import org.apache.thrift.async.AsyncMethodCallback;
40 import org.apache.thrift.async.TAsyncClient;
41 import org.apache.thrift.async.TAsyncClientFactory;
42 import org.apache.thrift.async.TAsyncClientManager;
43 import org.apache.thrift.async.TAsyncMethodCall;
44 import org.apache.thrift.meta_data.FieldMetaData;
45 import org.apache.thrift.meta_data.FieldValueMetaData;
46 import org.apache.thrift.meta_data.ListMetaData;
47 import org.apache.thrift.meta_data.StructMetaData;
48 import org.apache.thrift.protocol.TCompactProtocol;
49 import org.apache.thrift.protocol.TField;
50 import org.apache.thrift.protocol.TList;
51 import org.apache.thrift.protocol.TMessage;
52 import org.apache.thrift.protocol.TMessageType;
53 import org.apache.thrift.protocol.TProtocol;
54 import org.apache.thrift.protocol.TProtocolFactory;
55 import org.apache.thrift.protocol.TProtocolUtil;
56 import org.apache.thrift.protocol.TStruct;
57 import org.apache.thrift.protocol.TTupleProtocol;
58 import org.apache.thrift.protocol.TType;
59 import org.apache.thrift.scheme.IScheme;
60 import org.apache.thrift.scheme.SchemeFactory;
61 import org.apache.thrift.scheme.StandardScheme;
62 import org.apache.thrift.scheme.TupleScheme;
63 import org.apache.thrift.transport.TIOStreamTransport;
64 import org.apache.thrift.transport.TMemoryInputTransport;
65 import org.apache.thrift.transport.TNonblockingTransport;
66
67 import java.io.IOException;
68 import java.io.ObjectInputStream;
69 import java.io.ObjectOutputStream;
70 import java.util.ArrayList;
71 import java.util.BitSet;
72 import java.util.Collections;
73 import java.util.EnumMap;
74 import java.util.EnumSet;
75 import java.util.HashMap;
76 import java.util.Iterator;
77 import java.util.List;
78 import java.util.Map;
79
80 public class R66Service {
81 private static final String REQUEST3 = "request";
82 private static final String SUCCESS3 = "success";
83
84 public interface Iface {
85
86 R66Result transferRequestQuery(R66Request request) throws TException;
87
88 R66Result infoTransferQuery(R66Request request) throws TException;
89
90 boolean isStillRunning(String fromuid, String touid, long tid)
91 throws TException;
92
93 List<String> infoListQuery(R66Request request) throws TException;
94
95 }
96
97 public interface AsyncIface {
98
99 void transferRequestQuery(R66Request request,
100 AsyncMethodCallback<AsyncClient.transferRequestQuery_call> resultHandler)
101 throws TException;
102
103 void infoTransferQuery(R66Request request,
104 AsyncMethodCallback<AsyncClient.infoTransferQuery_call> resultHandler)
105 throws TException;
106
107 void isStillRunning(String fromuid, String touid, long tid,
108 AsyncMethodCallback<AsyncClient.isStillRunning_call> resultHandler)
109 throws TException;
110
111 void infoListQuery(R66Request request,
112 AsyncMethodCallback<AsyncClient.infoListQuery_call> resultHandler)
113 throws TException;
114
115 }
116
117 public static class Client extends TServiceClient implements Iface {
118 private static final String TRANSFER_REQUEST_QUERY = "transferRequestQuery";
119 private static final String IS_STILL_RUNNING = "isStillRunning";
120 private static final String INFO_TRANSFER_QUERY = "infoTransferQuery";
121 private static final String INFO_LIST_QUERY = "infoListQuery";
122
123 public static class Factory implements TServiceClientFactory<Client> {
124 public Factory() {
125
126 }
127
128 @Override
129 public final Client getClient(final TProtocol prot) {
130 return new Client(prot);
131 }
132
133 @Override
134 public final Client getClient(final TProtocol iprot,
135 final TProtocol oprot) {
136 return new Client(iprot, oprot);
137 }
138 }
139
140 public Client(final TProtocol prot) {
141 super(prot, prot);
142 }
143
144 public Client(final TProtocol iprot, final TProtocol oprot) {
145 super(iprot, oprot);
146 }
147
148 @Override
149 public final R66Result transferRequestQuery(final R66Request request)
150 throws TException {
151 send_transferRequestQuery(request);
152 return recv_transferRequestQuery();
153 }
154
155 public final void send_transferRequestQuery(final R66Request request)
156 throws TException {
157 final transferRequestQuery_args args = new transferRequestQuery_args();
158 args.setRequest(request);
159 sendBase(TRANSFER_REQUEST_QUERY, args);
160 }
161
162 public final R66Result recv_transferRequestQuery() throws TException {
163 final transferRequestQuery_result result =
164 new transferRequestQuery_result();
165 receiveBase(result, TRANSFER_REQUEST_QUERY);
166 if (result.isSetSuccess()) {
167 return result.success;
168 }
169 throw new TApplicationException(TApplicationException.MISSING_RESULT,
170 "transferRequestQuery failed: unknown result");
171 }
172
173 @Override
174 public final R66Result infoTransferQuery(final R66Request request)
175 throws TException {
176 send_infoTransferQuery(request);
177 return recv_infoTransferQuery();
178 }
179
180 public final void send_infoTransferQuery(final R66Request request)
181 throws TException {
182 final infoTransferQuery_args args = new infoTransferQuery_args();
183 args.setRequest(request);
184 sendBase(INFO_TRANSFER_QUERY, args);
185 }
186
187 public final R66Result recv_infoTransferQuery() throws TException {
188 final infoTransferQuery_result result = new infoTransferQuery_result();
189 receiveBase(result, INFO_TRANSFER_QUERY);
190 if (result.isSetSuccess()) {
191 return result.success;
192 }
193 throw new TApplicationException(TApplicationException.MISSING_RESULT,
194 "infoTransferQuery failed: unknown result");
195 }
196
197 @Override
198 public final boolean isStillRunning(final String fromuid,
199 final String touid, final long tid)
200 throws TException {
201 send_isStillRunning(fromuid, touid, tid);
202 return recv_isStillRunning();
203 }
204
205 public final void send_isStillRunning(final String fromuid,
206 final String touid, final long tid)
207 throws TException {
208 final isStillRunning_args args = new isStillRunning_args();
209 args.setFromuid(fromuid);
210 args.setTouid(touid);
211 args.setTid(tid);
212 sendBase(IS_STILL_RUNNING, args);
213 }
214
215 public final boolean recv_isStillRunning() throws TException {
216 final isStillRunning_result result = new isStillRunning_result();
217 receiveBase(result, IS_STILL_RUNNING);
218 if (result.isSetSuccess()) {
219 return result.success;
220 }
221 throw new TApplicationException(TApplicationException.MISSING_RESULT,
222 "isStillRunning failed: unknown result");
223 }
224
225 @Override
226 public final List<String> infoListQuery(final R66Request request)
227 throws TException {
228 send_infoListQuery(request);
229 return recv_infoListQuery();
230 }
231
232 public final void send_infoListQuery(final R66Request request)
233 throws TException {
234 final infoListQuery_args args = new infoListQuery_args();
235 args.setRequest(request);
236 sendBase(INFO_LIST_QUERY, args);
237 }
238
239 public final List<String> recv_infoListQuery() throws TException {
240 final infoListQuery_result result = new infoListQuery_result();
241 receiveBase(result, INFO_LIST_QUERY);
242 if (result.isSetSuccess()) {
243 return Collections.unmodifiableList(result.success);
244 }
245 throw new TApplicationException(TApplicationException.MISSING_RESULT,
246 "infoListQuery failed: unknown result");
247 }
248
249 }
250
251 public static class AsyncClient extends TAsyncClient implements AsyncIface {
252 public static class Factory implements TAsyncClientFactory<AsyncClient> {
253 private final TAsyncClientManager clientManager;
254 private final TProtocolFactory protocolFactory;
255
256 public Factory(final TAsyncClientManager clientManager,
257 final TProtocolFactory protocolFactory) {
258 this.clientManager = clientManager;
259 this.protocolFactory = protocolFactory;
260 }
261
262 @Override
263 public final AsyncClient getAsyncClient(
264 final TNonblockingTransport transport) {
265 return new AsyncClient(protocolFactory, clientManager, transport);
266 }
267 }
268
269 public AsyncClient(final TProtocolFactory protocolFactory,
270 final TAsyncClientManager clientManager,
271 final TNonblockingTransport transport) {
272 super(protocolFactory, clientManager, transport);
273 }
274
275 @Override
276 public final void transferRequestQuery(final R66Request request,
277 final AsyncMethodCallback<transferRequestQuery_call> resultHandler)
278 throws TException {
279 checkReady();
280 final transferRequestQuery_call transferRequestQueryCall =
281 new transferRequestQuery_call(request, resultHandler, this,
282 ___protocolFactory, ___transport);
283 ___currentMethod = transferRequestQueryCall;
284 ___manager.call(transferRequestQueryCall);
285 }
286
287 public static class transferRequestQuery_call
288 extends TAsyncMethodCall<transferRequestQuery_call> {
289 private static final String METHOD_CALL_NOT_FINISHED =
290 "Method call not finished!";
291 private final R66Request request;
292
293 public transferRequestQuery_call(final R66Request request,
294 final AsyncMethodCallback<transferRequestQuery_call> resultHandler,
295 final TAsyncClient client,
296 final TProtocolFactory protocolFactory,
297 final TNonblockingTransport transport)
298 throws TException {
299 super(client, protocolFactory, transport, resultHandler, false);
300 this.request = request;
301 }
302
303 @Override
304 public final void write_args(final TProtocol prot) throws TException {
305 prot.writeMessageBegin(
306 new TMessage("transferRequestQuery", TMessageType.CALL, 0));
307 final transferRequestQuery_args args = new transferRequestQuery_args();
308 args.setRequest(request);
309 args.write(prot);
310 prot.writeMessageEnd();
311 }
312
313 public final R66Result getResult() throws TException {
314 if (getState() != State.RESPONSE_READ) {
315 throw new IllegalStateException(METHOD_CALL_NOT_FINISHED);
316 }
317 final TMemoryInputTransport memoryTransport =
318 new TMemoryInputTransport(getFrameBuffer().array());
319 final TProtocol prot =
320 client.getProtocolFactory().getProtocol(memoryTransport);
321 return new Client(prot).recv_transferRequestQuery();
322 }
323 }
324
325 @Override
326 public final void infoTransferQuery(final R66Request request,
327 final AsyncMethodCallback<infoTransferQuery_call> resultHandler)
328 throws TException {
329 checkReady();
330 final infoTransferQuery_call infoTransferQueryCall =
331 new infoTransferQuery_call(request, resultHandler, this,
332 ___protocolFactory, ___transport);
333 ___currentMethod = infoTransferQueryCall;
334 ___manager.call(infoTransferQueryCall);
335 }
336
337 public static class infoTransferQuery_call
338 extends TAsyncMethodCall<infoTransferQuery_call> {
339 private static final String INFO_TRANSFER_QUERY = "infoTransferQuery";
340 private final R66Request request;
341
342 public infoTransferQuery_call(final R66Request request,
343 final AsyncMethodCallback<infoTransferQuery_call> resultHandler,
344 final TAsyncClient client,
345 final TProtocolFactory protocolFactory,
346 final TNonblockingTransport transport)
347 throws TException {
348 super(client, protocolFactory, transport, resultHandler, false);
349 this.request = request;
350 }
351
352 @Override
353 public final void write_args(final TProtocol prot) throws TException {
354 prot.writeMessageBegin(
355 new TMessage(INFO_TRANSFER_QUERY, TMessageType.CALL, 0));
356 final infoTransferQuery_args args = new infoTransferQuery_args();
357 args.setRequest(request);
358 args.write(prot);
359 prot.writeMessageEnd();
360 }
361
362 public final R66Result getResult() throws TException {
363 if (getState() != State.RESPONSE_READ) {
364 throw new IllegalStateException("Method call not finished!");
365 }
366 final TMemoryInputTransport memoryTransport =
367 new TMemoryInputTransport(getFrameBuffer().array());
368 final TProtocol prot =
369 client.getProtocolFactory().getProtocol(memoryTransport);
370 return new Client(prot).recv_infoTransferQuery();
371 }
372 }
373
374 @Override
375 public final void isStillRunning(final String fromuid, final String touid,
376 final long tid,
377 final AsyncMethodCallback<isStillRunning_call> resultHandler)
378 throws TException {
379 checkReady();
380 final isStillRunning_call isStillRunningCall =
381 new isStillRunning_call(fromuid, touid, tid, resultHandler, this,
382 ___protocolFactory, ___transport);
383 ___currentMethod = isStillRunningCall;
384 ___manager.call(isStillRunningCall);
385 }
386
387 public static class isStillRunning_call
388 extends TAsyncMethodCall<isStillRunning_call> {
389 private final String fromuid;
390 private final String touid;
391 private final long tid;
392
393 public isStillRunning_call(final String fromuid, final String touid,
394 final long tid,
395 final AsyncMethodCallback<isStillRunning_call> resultHandler,
396 final TAsyncClient client,
397 final TProtocolFactory protocolFactory,
398 final TNonblockingTransport transport)
399 throws TException {
400 super(client, protocolFactory, transport, resultHandler, false);
401 this.fromuid = fromuid;
402 this.touid = touid;
403 this.tid = tid;
404 }
405
406 @Override
407 public final void write_args(final TProtocol prot) throws TException {
408 prot.writeMessageBegin(
409 new TMessage("isStillRunning", TMessageType.CALL, 0));
410 final isStillRunning_args args = new isStillRunning_args();
411 args.setFromuid(fromuid);
412 args.setTouid(touid);
413 args.setTid(tid);
414 args.write(prot);
415 prot.writeMessageEnd();
416 }
417
418 public final boolean getResult() throws TException {
419 if (getState() != State.RESPONSE_READ) {
420 throw new IllegalStateException("Method call not finished!");
421 }
422 final TMemoryInputTransport memoryTransport =
423 new TMemoryInputTransport(getFrameBuffer().array());
424 final TProtocol prot =
425 client.getProtocolFactory().getProtocol(memoryTransport);
426 return new Client(prot).recv_isStillRunning();
427 }
428 }
429
430 @Override
431 public final void infoListQuery(final R66Request request,
432 final AsyncMethodCallback<infoListQuery_call> resultHandler)
433 throws TException {
434 checkReady();
435 final infoListQuery_call infoListQueryCall =
436 new infoListQuery_call(request, resultHandler, this,
437 ___protocolFactory, ___transport);
438 ___currentMethod = infoListQueryCall;
439 ___manager.call(infoListQueryCall);
440 }
441
442 public static class infoListQuery_call
443 extends TAsyncMethodCall<infoListQuery_call> {
444 private final R66Request request;
445
446 public infoListQuery_call(final R66Request request,
447 final AsyncMethodCallback<infoListQuery_call> resultHandler,
448 final TAsyncClient client,
449 final TProtocolFactory protocolFactory,
450 final TNonblockingTransport transport)
451 throws TException {
452 super(client, protocolFactory, transport, resultHandler, false);
453 this.request = request;
454 }
455
456 @Override
457 public final void write_args(final TProtocol prot) throws TException {
458 prot.writeMessageBegin(
459 new TMessage("infoListQuery", TMessageType.CALL, 0));
460 final infoListQuery_args args = new infoListQuery_args();
461 args.setRequest(request);
462 args.write(prot);
463 prot.writeMessageEnd();
464 }
465
466 public final List<String> getResult() throws TException {
467 if (getState() != State.RESPONSE_READ) {
468 throw new IllegalStateException("Method call not finished!");
469 }
470 final TMemoryInputTransport memoryTransport =
471 new TMemoryInputTransport(getFrameBuffer().array());
472 final TProtocol prot =
473 client.getProtocolFactory().getProtocol(memoryTransport);
474 return new Client(prot).recv_infoListQuery();
475 }
476 }
477
478 }
479
480 public static class Processor<I extends Iface> extends TBaseProcessor<I> {
481
482 public Processor(final I iface) {
483 super(iface, getProcessMap(
484 new HashMap<String, ProcessFunction<I, ? extends TBase>>()));
485 }
486
487 protected Processor(final I iface,
488 final Map<String, ProcessFunction<I, ? extends TBase>> processMap) {
489 super(iface, getProcessMap(processMap));
490 }
491
492 private static <I extends Iface> Map<String, ProcessFunction<I, ? extends TBase>> getProcessMap(
493 final Map<String, ProcessFunction<I, ? extends TBase>> processMap) {
494 processMap.put("transferRequestQuery",
495 (ProcessFunction<I, ? extends TBase>) new transferRequestQuery<Iface>());
496 processMap.put("infoTransferQuery",
497 (ProcessFunction<I, ? extends TBase>) new infoTransferQuery<Iface>());
498 processMap.put("isStillRunning",
499 (ProcessFunction<I, ? extends TBase>) new isStillRunning<Iface>());
500 processMap.put("infoListQuery",
501 (ProcessFunction<I, ? extends TBase>) new infoListQuery<Iface>());
502 return processMap;
503 }
504
505 public static class transferRequestQuery<I extends Iface>
506 extends ProcessFunction<I, transferRequestQuery_args> {
507 public transferRequestQuery() {
508 super("transferRequestQuery");
509 }
510
511 @Override
512 public final transferRequestQuery_args getEmptyArgsInstance() {
513 return new transferRequestQuery_args();
514 }
515
516 @Override
517 protected final boolean isOneway() {
518 return false;
519 }
520
521 @Override
522 public final transferRequestQuery_result getResult(final I iface,
523 final transferRequestQuery_args args)
524 throws TException {
525 final transferRequestQuery_result result =
526 new transferRequestQuery_result();
527 result.success = iface.transferRequestQuery(args.request);
528 return result;
529 }
530 }
531
532 public static class infoTransferQuery<I extends Iface>
533 extends ProcessFunction<I, infoTransferQuery_args> {
534 public infoTransferQuery() {
535 super("infoTransferQuery");
536 }
537
538 @Override
539 public final infoTransferQuery_args getEmptyArgsInstance() {
540 return new infoTransferQuery_args();
541 }
542
543 @Override
544 protected final boolean isOneway() {
545 return false;
546 }
547
548 @Override
549 public final infoTransferQuery_result getResult(final I iface,
550 final infoTransferQuery_args args)
551 throws TException {
552 final infoTransferQuery_result result = new infoTransferQuery_result();
553 result.success = iface.infoTransferQuery(args.request);
554 return result;
555 }
556 }
557
558 public static class isStillRunning<I extends Iface>
559 extends ProcessFunction<I, isStillRunning_args> {
560 public isStillRunning() {
561 super("isStillRunning");
562 }
563
564 @Override
565 public final isStillRunning_args getEmptyArgsInstance() {
566 return new isStillRunning_args();
567 }
568
569 @Override
570 protected final boolean isOneway() {
571 return false;
572 }
573
574 @Override
575 public final isStillRunning_result getResult(final I iface,
576 final isStillRunning_args args)
577 throws TException {
578 final isStillRunning_result result = new isStillRunning_result();
579 result.success =
580 iface.isStillRunning(args.fromuid, args.touid, args.tid);
581 result.setSuccessIsSet(true);
582 return result;
583 }
584 }
585
586 public static class infoListQuery<I extends Iface>
587 extends ProcessFunction<I, infoListQuery_args> {
588 public infoListQuery() {
589 super("infoListQuery");
590 }
591
592 @Override
593 public final infoListQuery_args getEmptyArgsInstance() {
594 return new infoListQuery_args();
595 }
596
597 @Override
598 protected final boolean isOneway() {
599 return false;
600 }
601
602 @Override
603 public final infoListQuery_result getResult(final I iface,
604 final infoListQuery_args args)
605 throws TException {
606 final infoListQuery_result result = new infoListQuery_result();
607 result.success = iface.infoListQuery(args.request);
608 return result;
609 }
610 }
611
612 }
613
614 public static class transferRequestQuery_args implements
615 TBase<transferRequestQuery_args, transferRequestQuery_args._Fields>,
616 Cloneable {
617
618 private static final String REQUEST2 = "request:";
619
620
621
622
623 private static final long serialVersionUID = 6110060994329259224L;
624
625 private static final TStruct STRUCT_DESC =
626 new TStruct("transferRequestQuery_args");
627
628 private static final TField REQUEST_FIELD_DESC =
629 new TField(REQUEST3, TType.STRUCT, (short) 1);
630
631 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
632 new HashMap<Class<? extends IScheme>, SchemeFactory>();
633
634 static {
635 schemes.put(StandardScheme.class,
636 new transferRequestQuery_argsStandardSchemeFactory());
637 schemes.put(TupleScheme.class,
638 new transferRequestQuery_argsTupleSchemeFactory());
639 }
640
641 private R66Request request;
642
643 @Override
644 public final transferRequestQuery_args clone()
645 throws CloneNotSupportedException {
646 return (transferRequestQuery_args) super.clone();
647 }
648
649
650
651
652
653
654 public enum _Fields implements TFieldIdEnum {
655 REQUEST((short) 1, REQUEST3);
656
657 private static final String FIELD = "Field ";
658 private static final String DOESN_T_EXIST = " doesn't exist!";
659 private static final Map<String, _Fields> byName =
660 new HashMap<String, _Fields>();
661
662 static {
663 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
664 byName.put(field.getFieldName(), field);
665 }
666 }
667
668
669
670
671
672
673 public static _Fields findByThriftId(final int fieldId) {
674 if (fieldId == 1) {
675 return REQUEST;
676 }
677 return null;
678 }
679
680
681
682
683
684
685 public static _Fields findByThriftIdOrThrow(final int fieldId) {
686 final _Fields fields = findByThriftId(fieldId);
687 if (fields == null) {
688 throw new IllegalArgumentException(FIELD + fieldId + DOESN_T_EXIST);
689 }
690 return fields;
691 }
692
693
694
695
696
697 public static _Fields findByName(final String name) {
698 return byName.get(name);
699 }
700
701 private final short thriftId;
702 private final String fieldName;
703
704 _Fields(final short thriftId, final String fieldName) {
705 this.thriftId = thriftId;
706 this.fieldName = fieldName;
707 }
708
709 @Override
710 public final short getThriftFieldId() {
711 return thriftId;
712 }
713
714 @Override
715 public final String getFieldName() {
716 return fieldName;
717 }
718 }
719
720
721 public static final Map<_Fields, FieldMetaData> metaDataMap;
722
723 static {
724 final Map<_Fields, FieldMetaData> tmpMap =
725 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
726 tmpMap.put(_Fields.REQUEST,
727 new FieldMetaData(REQUEST3, TFieldRequirementType.DEFAULT,
728 new StructMetaData(TType.STRUCT,
729 R66Request.class)));
730 metaDataMap = Collections.unmodifiableMap(tmpMap);
731 FieldMetaData.addStructMetaDataMap(transferRequestQuery_args.class,
732 metaDataMap);
733 }
734
735 public transferRequestQuery_args() {
736 }
737
738 public transferRequestQuery_args(final R66Request request) {
739 this();
740 this.request = request;
741 }
742
743
744
745
746 public transferRequestQuery_args(final transferRequestQuery_args other) {
747 if (other.isSetRequest()) {
748 request = new R66Request(other.request);
749 }
750 }
751
752 @Override
753 public final transferRequestQuery_args deepCopy() {
754 return new transferRequestQuery_args(this);
755 }
756
757 @Override
758 public final void clear() {
759 request = null;
760 }
761
762 public final R66Request getRequest() {
763 return request;
764 }
765
766 public final transferRequestQuery_args setRequest(
767 final R66Request request) {
768 this.request = request;
769 return this;
770 }
771
772 public final void unsetRequest() {
773 request = null;
774 }
775
776
777
778
779
780 public final boolean isSetRequest() {
781 return request != null;
782 }
783
784 public final void setRequestIsSet(final boolean value) {
785 if (!value) {
786 request = null;
787 }
788 }
789
790 @Override
791 public final void setFieldValue(final _Fields field, final Object value) {
792 if (field == _Fields.REQUEST) {
793 if (value == null) {
794 unsetRequest();
795 } else {
796 setRequest((R66Request) value);
797 }
798 }
799 }
800
801 @Override
802 public final Object getFieldValue(final _Fields field) {
803 if (field == _Fields.REQUEST) {
804 return getRequest();
805 }
806 throw new IllegalStateException();
807 }
808
809
810
811
812
813
814 @Override
815 public final boolean isSet(final _Fields field) {
816 if (field == null) {
817 throw new IllegalArgumentException();
818 }
819
820 if (field == _Fields.REQUEST) {
821 return isSetRequest();
822 }
823 throw new IllegalStateException();
824 }
825
826 @Override
827 public final boolean equals(final Object that) {
828 if (that == null) {
829 return false;
830 }
831 if (that instanceof transferRequestQuery_args) {
832 return equals((transferRequestQuery_args) that);
833 }
834 return false;
835 }
836
837 public final boolean equals(final transferRequestQuery_args that) {
838 if (that == null) {
839 return false;
840 }
841
842 final boolean this_present_request = isSetRequest();
843 final boolean that_present_request = that.isSetRequest();
844 if (this_present_request || that_present_request) {
845 if (!(this_present_request && that_present_request)) {
846 return false;
847 }
848 return request.equals(that.request);
849 }
850
851 return true;
852 }
853
854 @Override
855 public final int hashCode() {
856 return 0;
857 }
858
859 @Override
860 public final int compareTo(final transferRequestQuery_args other) {
861 if (!getClass().equals(other.getClass())) {
862 return getClass().getName().compareTo(other.getClass().getName());
863 }
864
865 int lastComparison;
866
867 lastComparison =
868 Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest());
869 if (lastComparison != 0) {
870 return lastComparison;
871 }
872 if (isSetRequest()) {
873 lastComparison = TBaseHelper.compareTo(request, other.request);
874 return lastComparison;
875 }
876 return 0;
877 }
878
879 @Override
880 public final _Fields fieldForId(final int fieldId) {
881 return _Fields.findByThriftId(fieldId);
882 }
883
884 @Override
885 public final void read(final TProtocol iprot) throws TException {
886 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
887 }
888
889 @Override
890 public final void write(final TProtocol oprot) throws TException {
891 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
892 }
893
894 @Override
895 public final String toString() {
896 final StringBuilder sb = new StringBuilder("transferRequestQuery_args(");
897 sb.append(REQUEST2);
898 if (request == null) {
899 sb.append("null");
900 } else {
901 sb.append(request);
902 }
903 sb.append(')');
904 return sb.toString();
905 }
906
907 public final void validate() throws TException {
908
909
910 if (request != null) {
911 request.validate();
912 }
913 }
914
915 private void writeObject(final ObjectOutputStream out) throws IOException {
916 try {
917 write(new TCompactProtocol(new TIOStreamTransport(out)));
918 } catch (final TException te) {
919 throw new IOException(te);
920 }
921 }
922
923 private void readObject(final ObjectInputStream in)
924 throws IOException, ClassNotFoundException {
925 try {
926 read(new TCompactProtocol(new TIOStreamTransport(in)));
927 } catch (final TException te) {
928 throw new IOException(te);
929 }
930 }
931
932 private static class transferRequestQuery_argsStandardSchemeFactory
933 implements SchemeFactory {
934 @Override
935 public final transferRequestQuery_argsStandardScheme getScheme() {
936 return new transferRequestQuery_argsStandardScheme();
937 }
938 }
939
940 private static class transferRequestQuery_argsStandardScheme
941 extends StandardScheme<transferRequestQuery_args> {
942
943 @Override
944 public final void read(final TProtocol iprot,
945 final transferRequestQuery_args struct)
946 throws TException {
947 TField schemeField;
948 iprot.readStructBegin();
949 while (true) {
950 schemeField = iprot.readFieldBegin();
951 if (schemeField.type == TType.STOP) {
952 break;
953 }
954 if (schemeField.id == 1) {
955 if (schemeField.type == TType.STRUCT) {
956 struct.request = new R66Request();
957 struct.request.read(iprot);
958 struct.setRequestIsSet(true);
959 } else {
960 TProtocolUtil.skip(iprot, schemeField.type);
961 }
962 } else {
963 TProtocolUtil.skip(iprot, schemeField.type);
964 }
965 iprot.readFieldEnd();
966 }
967 iprot.readStructEnd();
968
969
970
971 struct.validate();
972 }
973
974 @Override
975 public final void write(final TProtocol oprot,
976 final transferRequestQuery_args struct)
977 throws TException {
978 struct.validate();
979
980 oprot.writeStructBegin(STRUCT_DESC);
981 if (struct.request != null) {
982 oprot.writeFieldBegin(REQUEST_FIELD_DESC);
983 struct.request.write(oprot);
984 oprot.writeFieldEnd();
985 }
986 oprot.writeFieldStop();
987 oprot.writeStructEnd();
988 }
989
990 }
991
992 private static class transferRequestQuery_argsTupleSchemeFactory
993 implements SchemeFactory {
994 @Override
995 public final transferRequestQuery_argsTupleScheme getScheme() {
996 return new transferRequestQuery_argsTupleScheme();
997 }
998 }
999
1000 private static class transferRequestQuery_argsTupleScheme
1001 extends TupleScheme<transferRequestQuery_args> {
1002
1003 @Override
1004 public final void write(final TProtocol prot,
1005 final transferRequestQuery_args struct)
1006 throws TException {
1007 final TTupleProtocol oprot = (TTupleProtocol) prot;
1008 final BitSet optionals = new BitSet();
1009 if (struct.isSetRequest()) {
1010 optionals.set(0);
1011 }
1012 oprot.writeBitSet(optionals, 1);
1013 if (struct.isSetRequest()) {
1014 struct.request.write(oprot);
1015 }
1016 }
1017
1018 @Override
1019 public final void read(final TProtocol prot,
1020 final transferRequestQuery_args struct)
1021 throws TException {
1022 final TTupleProtocol iprot = (TTupleProtocol) prot;
1023 final BitSet incoming = iprot.readBitSet(1);
1024 if (incoming.get(0)) {
1025 struct.request = new R66Request();
1026 struct.request.read(iprot);
1027 struct.setRequestIsSet(true);
1028 }
1029 }
1030 }
1031
1032 }
1033
1034 public static class transferRequestQuery_result implements
1035 TBase<transferRequestQuery_result, transferRequestQuery_result._Fields>,
1036 Cloneable {
1037
1038 private static final String SUCCESS2 = "success:";
1039
1040
1041
1042
1043 private static final long serialVersionUID = 6094115747732277098L;
1044
1045 private static final TStruct STRUCT_DESC =
1046 new TStruct("transferRequestQuery_result");
1047
1048 private static final TField SUCCESS_FIELD_DESC =
1049 new TField(SUCCESS3, TType.STRUCT, (short) 0);
1050
1051 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
1052 new HashMap<Class<? extends IScheme>, SchemeFactory>();
1053
1054 static {
1055 schemes.put(StandardScheme.class,
1056 new transferRequestQuery_resultStandardSchemeFactory());
1057 schemes.put(TupleScheme.class,
1058 new transferRequestQuery_resultTupleSchemeFactory());
1059 }
1060
1061 private R66Result success;
1062
1063 @Override
1064 public final transferRequestQuery_result clone()
1065 throws CloneNotSupportedException {
1066 return (transferRequestQuery_result) super.clone();
1067 }
1068
1069
1070
1071
1072
1073
1074 public enum _Fields implements TFieldIdEnum {
1075 SUCCESS((short) 0, SUCCESS3);
1076
1077 private static final Map<String, _Fields> byName =
1078 new HashMap<String, _Fields>();
1079
1080 static {
1081 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
1082 byName.put(field.getFieldName(), field);
1083 }
1084 }
1085
1086
1087
1088
1089
1090
1091 public static _Fields findByThriftId(final int fieldId) {
1092 if (fieldId == 0) {
1093 return SUCCESS;
1094 }
1095 return null;
1096 }
1097
1098
1099
1100
1101
1102
1103 public static _Fields findByThriftIdOrThrow(final int fieldId) {
1104 final _Fields fields = findByThriftId(fieldId);
1105 if (fields == null) {
1106 throw new IllegalArgumentException(
1107 "Field " + fieldId + " doesn't exist!");
1108 }
1109 return fields;
1110 }
1111
1112
1113
1114
1115
1116 public static _Fields findByName(final String name) {
1117 return byName.get(name);
1118 }
1119
1120 private final short thriftId;
1121 private final String fieldName;
1122
1123 _Fields(final short thriftId, final String fieldName) {
1124 this.thriftId = thriftId;
1125 this.fieldName = fieldName;
1126 }
1127
1128 @Override
1129 public final short getThriftFieldId() {
1130 return thriftId;
1131 }
1132
1133 @Override
1134 public final String getFieldName() {
1135 return fieldName;
1136 }
1137 }
1138
1139
1140 public static final Map<_Fields, FieldMetaData> metaDataMap;
1141
1142 static {
1143 final Map<_Fields, FieldMetaData> tmpMap =
1144 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
1145 tmpMap.put(_Fields.SUCCESS,
1146 new FieldMetaData(SUCCESS3, TFieldRequirementType.DEFAULT,
1147 new StructMetaData(TType.STRUCT,
1148 R66Result.class)));
1149 metaDataMap = Collections.unmodifiableMap(tmpMap);
1150 FieldMetaData.addStructMetaDataMap(transferRequestQuery_result.class,
1151 metaDataMap);
1152 }
1153
1154 public transferRequestQuery_result() {
1155 }
1156
1157 public transferRequestQuery_result(final R66Result success) {
1158 this();
1159 this.success = success;
1160 }
1161
1162
1163
1164
1165 public transferRequestQuery_result(
1166 final transferRequestQuery_result other) {
1167 if (other.isSetSuccess()) {
1168 success = new R66Result(other.success);
1169 }
1170 }
1171
1172 @Override
1173 public final transferRequestQuery_result deepCopy() {
1174 return new transferRequestQuery_result(this);
1175 }
1176
1177 @Override
1178 public final void clear() {
1179 success = null;
1180 }
1181
1182 public final R66Result getSuccess() {
1183 return success;
1184 }
1185
1186 public final transferRequestQuery_result setSuccess(
1187 final R66Result success) {
1188 this.success = success;
1189 return this;
1190 }
1191
1192 public final void unsetSuccess() {
1193 success = null;
1194 }
1195
1196
1197
1198
1199
1200 public final boolean isSetSuccess() {
1201 return success != null;
1202 }
1203
1204 public final void setSuccessIsSet(final boolean value) {
1205 if (!value) {
1206 success = null;
1207 }
1208 }
1209
1210 @Override
1211 public final void setFieldValue(final _Fields field, final Object value) {
1212 if (field == _Fields.SUCCESS) {
1213 if (value == null) {
1214 unsetSuccess();
1215 } else {
1216 setSuccess((R66Result) value);
1217 }
1218 }
1219 }
1220
1221 @Override
1222 public final Object getFieldValue(final _Fields field) {
1223 if (field == _Fields.SUCCESS) {
1224 return getSuccess();
1225 }
1226 throw new IllegalStateException();
1227 }
1228
1229
1230
1231
1232
1233
1234 @Override
1235 public final boolean isSet(final _Fields field) {
1236 if (field == null) {
1237 throw new IllegalArgumentException();
1238 }
1239
1240 if (field == _Fields.SUCCESS) {
1241 return isSetSuccess();
1242 }
1243 throw new IllegalStateException();
1244 }
1245
1246 @Override
1247 public final boolean equals(final Object that) {
1248 if (that == null) {
1249 return false;
1250 }
1251 if (that instanceof transferRequestQuery_result) {
1252 return equals((transferRequestQuery_result) that);
1253 }
1254 return false;
1255 }
1256
1257 public final boolean equals(final transferRequestQuery_result that) {
1258 if (that == null) {
1259 return false;
1260 }
1261
1262 final boolean this_present_success = isSetSuccess();
1263 final boolean that_present_success = that.isSetSuccess();
1264 if (this_present_success || that_present_success) {
1265 if (!(this_present_success && that_present_success)) {
1266 return false;
1267 }
1268 return success.equals(that.success);
1269 }
1270
1271 return true;
1272 }
1273
1274 @Override
1275 public final int hashCode() {
1276 return 0;
1277 }
1278
1279 @Override
1280 public final int compareTo(final transferRequestQuery_result other) {
1281 if (!getClass().equals(other.getClass())) {
1282 return getClass().getName().compareTo(other.getClass().getName());
1283 }
1284
1285 int lastComparison;
1286
1287 lastComparison =
1288 Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
1289 if (lastComparison != 0) {
1290 return lastComparison;
1291 }
1292 if (isSetSuccess()) {
1293 lastComparison = TBaseHelper.compareTo(success, other.success);
1294 return lastComparison;
1295 }
1296 return 0;
1297 }
1298
1299 @Override
1300 public final _Fields fieldForId(final int fieldId) {
1301 return _Fields.findByThriftId(fieldId);
1302 }
1303
1304 @Override
1305 public final void read(final TProtocol iprot) throws TException {
1306 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1307 }
1308
1309 @Override
1310 public final void write(final TProtocol oprot) throws TException {
1311 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1312 }
1313
1314 @Override
1315 public final String toString() {
1316 final StringBuilder sb =
1317 new StringBuilder("transferRequestQuery_result(");
1318 sb.append(SUCCESS2);
1319 if (success == null) {
1320 sb.append("null");
1321 } else {
1322 sb.append(success);
1323 }
1324 sb.append(')');
1325 return sb.toString();
1326 }
1327
1328 public final void validate() throws TException {
1329
1330
1331 if (success != null) {
1332 success.validate();
1333 }
1334 }
1335
1336 private void writeObject(final ObjectOutputStream out) throws IOException {
1337 try {
1338 write(new TCompactProtocol(new TIOStreamTransport(out)));
1339 } catch (final TException te) {
1340 throw new IOException(te);
1341 }
1342 }
1343
1344 private void readObject(final ObjectInputStream in)
1345 throws IOException, ClassNotFoundException {
1346 try {
1347 read(new TCompactProtocol(new TIOStreamTransport(in)));
1348 } catch (final TException te) {
1349 throw new IOException(te);
1350 }
1351 }
1352
1353 private static class transferRequestQuery_resultStandardSchemeFactory
1354 implements SchemeFactory {
1355 @Override
1356 public final transferRequestQuery_resultStandardScheme getScheme() {
1357 return new transferRequestQuery_resultStandardScheme();
1358 }
1359 }
1360
1361 private static class transferRequestQuery_resultStandardScheme
1362 extends StandardScheme<transferRequestQuery_result> {
1363
1364 @Override
1365 public final void read(final TProtocol iprot,
1366 final transferRequestQuery_result struct)
1367 throws TException {
1368 TField schemeField;
1369 iprot.readStructBegin();
1370 while (true) {
1371 schemeField = iprot.readFieldBegin();
1372 if (schemeField.type == TType.STOP) {
1373 break;
1374 }
1375 if (schemeField.id == 0) {
1376 if (schemeField.type == TType.STRUCT) {
1377 struct.success = new R66Result();
1378 struct.success.read(iprot);
1379 struct.setSuccessIsSet(true);
1380 } else {
1381 TProtocolUtil.skip(iprot, schemeField.type);
1382 }
1383 } else {
1384 TProtocolUtil.skip(iprot, schemeField.type);
1385 }
1386 iprot.readFieldEnd();
1387 }
1388 iprot.readStructEnd();
1389
1390
1391
1392 struct.validate();
1393 }
1394
1395 @Override
1396 public final void write(final TProtocol oprot,
1397 final transferRequestQuery_result struct)
1398 throws TException {
1399 struct.validate();
1400
1401 oprot.writeStructBegin(STRUCT_DESC);
1402 if (struct.success != null) {
1403 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
1404 struct.success.write(oprot);
1405 oprot.writeFieldEnd();
1406 }
1407 oprot.writeFieldStop();
1408 oprot.writeStructEnd();
1409 }
1410
1411 }
1412
1413 private static class transferRequestQuery_resultTupleSchemeFactory
1414 implements SchemeFactory {
1415 @Override
1416 public final transferRequestQuery_resultTupleScheme getScheme() {
1417 return new transferRequestQuery_resultTupleScheme();
1418 }
1419 }
1420
1421 private static class transferRequestQuery_resultTupleScheme
1422 extends TupleScheme<transferRequestQuery_result> {
1423
1424 @Override
1425 public final void write(final TProtocol prot,
1426 final transferRequestQuery_result struct)
1427 throws TException {
1428 final TTupleProtocol oprot = (TTupleProtocol) prot;
1429 final BitSet optionals = new BitSet();
1430 if (struct.isSetSuccess()) {
1431 optionals.set(0);
1432 }
1433 oprot.writeBitSet(optionals, 1);
1434 if (struct.isSetSuccess()) {
1435 struct.success.write(oprot);
1436 }
1437 }
1438
1439 @Override
1440 public final void read(final TProtocol prot,
1441 final transferRequestQuery_result struct)
1442 throws TException {
1443 final TTupleProtocol iprot = (TTupleProtocol) prot;
1444 final BitSet incoming = iprot.readBitSet(1);
1445 if (incoming.get(0)) {
1446 struct.success = new R66Result();
1447 struct.success.read(iprot);
1448 struct.setSuccessIsSet(true);
1449 }
1450 }
1451 }
1452
1453 }
1454
1455 public static class infoTransferQuery_args
1456 implements TBase<infoTransferQuery_args, infoTransferQuery_args._Fields>,
1457 Cloneable {
1458
1459
1460
1461 private static final long serialVersionUID = 964166304678767871L;
1462
1463 private static final TStruct STRUCT_DESC =
1464 new TStruct("infoTransferQuery_args");
1465
1466 private static final TField REQUEST_FIELD_DESC =
1467 new TField("request", TType.STRUCT, (short) 1);
1468
1469 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
1470 new HashMap<Class<? extends IScheme>, SchemeFactory>();
1471
1472 static {
1473 schemes.put(StandardScheme.class,
1474 new infoTransferQuery_argsStandardSchemeFactory());
1475 schemes.put(TupleScheme.class,
1476 new infoTransferQuery_argsTupleSchemeFactory());
1477 }
1478
1479 private R66Request request;
1480
1481 @Override
1482 public final infoTransferQuery_args clone()
1483 throws CloneNotSupportedException {
1484 return (infoTransferQuery_args) super.clone();
1485 }
1486
1487
1488
1489
1490
1491
1492 public enum _Fields implements TFieldIdEnum {
1493 REQUEST((short) 1, REQUEST3);
1494
1495 private static final Map<String, _Fields> byName =
1496 new HashMap<String, _Fields>();
1497
1498 static {
1499 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
1500 byName.put(field.getFieldName(), field);
1501 }
1502 }
1503
1504
1505
1506
1507
1508
1509 public static _Fields findByThriftId(final int fieldId) {
1510 if (fieldId == 1) {
1511 return REQUEST;
1512 }
1513 return null;
1514 }
1515
1516
1517
1518
1519
1520
1521 public static _Fields findByThriftIdOrThrow(final int fieldId) {
1522 final _Fields fields = findByThriftId(fieldId);
1523 if (fields == null) {
1524 throw new IllegalArgumentException(
1525 "Field " + fieldId + " doesn't exist!");
1526 }
1527 return fields;
1528 }
1529
1530
1531
1532
1533
1534 public static _Fields findByName(final String name) {
1535 return byName.get(name);
1536 }
1537
1538 private final short thriftId;
1539 private final String fieldName;
1540
1541 _Fields(final short thriftId, final String fieldName) {
1542 this.thriftId = thriftId;
1543 this.fieldName = fieldName;
1544 }
1545
1546 @Override
1547 public final short getThriftFieldId() {
1548 return thriftId;
1549 }
1550
1551 @Override
1552 public final String getFieldName() {
1553 return fieldName;
1554 }
1555 }
1556
1557
1558 public static final Map<_Fields, FieldMetaData> metaDataMap;
1559
1560 static {
1561 final Map<_Fields, FieldMetaData> tmpMap =
1562 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
1563 tmpMap.put(_Fields.REQUEST,
1564 new FieldMetaData("request", TFieldRequirementType.DEFAULT,
1565 new StructMetaData(TType.STRUCT,
1566 R66Request.class)));
1567 metaDataMap = Collections.unmodifiableMap(tmpMap);
1568 FieldMetaData.addStructMetaDataMap(infoTransferQuery_args.class,
1569 metaDataMap);
1570 }
1571
1572 public infoTransferQuery_args() {
1573 }
1574
1575 public infoTransferQuery_args(final R66Request request) {
1576 this();
1577 this.request = request;
1578 }
1579
1580
1581
1582
1583 public infoTransferQuery_args(final infoTransferQuery_args other) {
1584 if (other.isSetRequest()) {
1585 request = new R66Request(other.request);
1586 }
1587 }
1588
1589 @Override
1590 public final infoTransferQuery_args deepCopy() {
1591 return new infoTransferQuery_args(this);
1592 }
1593
1594 @Override
1595 public final void clear() {
1596 request = null;
1597 }
1598
1599 public final R66Request getRequest() {
1600 return request;
1601 }
1602
1603 public final infoTransferQuery_args setRequest(final R66Request request) {
1604 this.request = request;
1605 return this;
1606 }
1607
1608 public final void unsetRequest() {
1609 request = null;
1610 }
1611
1612
1613
1614
1615
1616 public final boolean isSetRequest() {
1617 return request != null;
1618 }
1619
1620 public final void setRequestIsSet(final boolean value) {
1621 if (!value) {
1622 request = null;
1623 }
1624 }
1625
1626 @Override
1627 public final void setFieldValue(final _Fields field, final Object value) {
1628 if (field == _Fields.REQUEST) {
1629 if (value == null) {
1630 unsetRequest();
1631 } else {
1632 setRequest((R66Request) value);
1633 }
1634 }
1635 }
1636
1637 @Override
1638 public final Object getFieldValue(final _Fields field) {
1639 if (field == _Fields.REQUEST) {
1640 return getRequest();
1641 }
1642 throw new IllegalStateException();
1643 }
1644
1645
1646
1647
1648
1649
1650 @Override
1651 public final boolean isSet(final _Fields field) {
1652 if (field == null) {
1653 throw new IllegalArgumentException();
1654 }
1655
1656 if (field == _Fields.REQUEST) {
1657 return isSetRequest();
1658 }
1659 throw new IllegalStateException();
1660 }
1661
1662 @Override
1663 public final boolean equals(final Object that) {
1664 if (that == null) {
1665 return false;
1666 }
1667 if (that instanceof infoTransferQuery_args) {
1668 return equals((infoTransferQuery_args) that);
1669 }
1670 return false;
1671 }
1672
1673 public final boolean equals(final infoTransferQuery_args that) {
1674 if (that == null) {
1675 return false;
1676 }
1677
1678 final boolean this_present_request = isSetRequest();
1679 final boolean that_present_request = that.isSetRequest();
1680 if (this_present_request || that_present_request) {
1681 if (!(this_present_request && that_present_request)) {
1682 return false;
1683 }
1684 return request.equals(that.request);
1685 }
1686
1687 return true;
1688 }
1689
1690 @Override
1691 public final int hashCode() {
1692 return 0;
1693 }
1694
1695 @Override
1696 public final int compareTo(final infoTransferQuery_args other) {
1697 if (!getClass().equals(other.getClass())) {
1698 return getClass().getName().compareTo(other.getClass().getName());
1699 }
1700
1701 int lastComparison;
1702
1703 lastComparison =
1704 Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest());
1705 if (lastComparison != 0) {
1706 return lastComparison;
1707 }
1708 if (isSetRequest()) {
1709 lastComparison = TBaseHelper.compareTo(request, other.request);
1710 return lastComparison;
1711 }
1712 return 0;
1713 }
1714
1715 @Override
1716 public final _Fields fieldForId(final int fieldId) {
1717 return _Fields.findByThriftId(fieldId);
1718 }
1719
1720 @Override
1721 public final void read(final TProtocol iprot) throws TException {
1722 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1723 }
1724
1725 @Override
1726 public final void write(final TProtocol oprot) throws TException {
1727 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1728 }
1729
1730 @Override
1731 public final String toString() {
1732 final StringBuilder sb = new StringBuilder("infoTransferQuery_args(");
1733 sb.append("request:");
1734 if (request == null) {
1735 sb.append("null");
1736 } else {
1737 sb.append(request);
1738 }
1739 sb.append(')');
1740 return sb.toString();
1741 }
1742
1743 public final void validate() throws TException {
1744
1745
1746 if (request != null) {
1747 request.validate();
1748 }
1749 }
1750
1751 private void writeObject(final ObjectOutputStream out) throws IOException {
1752 try {
1753 write(new TCompactProtocol(new TIOStreamTransport(out)));
1754 } catch (final TException te) {
1755 throw new IOException(te);
1756 }
1757 }
1758
1759 private void readObject(final ObjectInputStream in)
1760 throws IOException, ClassNotFoundException {
1761 try {
1762 read(new TCompactProtocol(new TIOStreamTransport(in)));
1763 } catch (final TException te) {
1764 throw new IOException(te);
1765 }
1766 }
1767
1768 private static class infoTransferQuery_argsStandardSchemeFactory
1769 implements SchemeFactory {
1770 @Override
1771 public final infoTransferQuery_argsStandardScheme getScheme() {
1772 return new infoTransferQuery_argsStandardScheme();
1773 }
1774 }
1775
1776 private static class infoTransferQuery_argsStandardScheme
1777 extends StandardScheme<infoTransferQuery_args> {
1778
1779 @Override
1780 public final void read(final TProtocol iprot,
1781 final infoTransferQuery_args struct)
1782 throws TException {
1783 TField schemeField;
1784 iprot.readStructBegin();
1785 while (true) {
1786 schemeField = iprot.readFieldBegin();
1787 if (schemeField.type == TType.STOP) {
1788 break;
1789 }
1790 if (schemeField.id == 1) {
1791 if (schemeField.type == TType.STRUCT) {
1792 struct.request = new R66Request();
1793 struct.request.read(iprot);
1794 struct.setRequestIsSet(true);
1795 } else {
1796 TProtocolUtil.skip(iprot, schemeField.type);
1797 }
1798 } else {
1799 TProtocolUtil.skip(iprot, schemeField.type);
1800 }
1801 iprot.readFieldEnd();
1802 }
1803 iprot.readStructEnd();
1804
1805
1806
1807 struct.validate();
1808 }
1809
1810 @Override
1811 public final void write(final TProtocol oprot,
1812 final infoTransferQuery_args struct)
1813 throws TException {
1814 struct.validate();
1815
1816 oprot.writeStructBegin(STRUCT_DESC);
1817 if (struct.request != null) {
1818 oprot.writeFieldBegin(REQUEST_FIELD_DESC);
1819 struct.request.write(oprot);
1820 oprot.writeFieldEnd();
1821 }
1822 oprot.writeFieldStop();
1823 oprot.writeStructEnd();
1824 }
1825
1826 }
1827
1828 private static class infoTransferQuery_argsTupleSchemeFactory
1829 implements SchemeFactory {
1830 @Override
1831 public final infoTransferQuery_argsTupleScheme getScheme() {
1832 return new infoTransferQuery_argsTupleScheme();
1833 }
1834 }
1835
1836 private static class infoTransferQuery_argsTupleScheme
1837 extends TupleScheme<infoTransferQuery_args> {
1838
1839 @Override
1840 public final void write(final TProtocol prot,
1841 final infoTransferQuery_args struct)
1842 throws TException {
1843 final TTupleProtocol oprot = (TTupleProtocol) prot;
1844 final BitSet optionals = new BitSet();
1845 if (struct.isSetRequest()) {
1846 optionals.set(0);
1847 }
1848 oprot.writeBitSet(optionals, 1);
1849 if (struct.isSetRequest()) {
1850 struct.request.write(oprot);
1851 }
1852 }
1853
1854 @Override
1855 public final void read(final TProtocol prot,
1856 final infoTransferQuery_args struct)
1857 throws TException {
1858 final TTupleProtocol iprot = (TTupleProtocol) prot;
1859 final BitSet incoming = iprot.readBitSet(1);
1860 if (incoming.get(0)) {
1861 struct.request = new R66Request();
1862 struct.request.read(iprot);
1863 struct.setRequestIsSet(true);
1864 }
1865 }
1866 }
1867
1868 }
1869
1870 public static class infoTransferQuery_result implements
1871 TBase<infoTransferQuery_result, infoTransferQuery_result._Fields>,
1872 Cloneable {
1873
1874
1875
1876 private static final long serialVersionUID = 7107861839746005751L;
1877
1878 private static final TStruct STRUCT_DESC =
1879 new TStruct("infoTransferQuery_result");
1880
1881 private static final TField SUCCESS_FIELD_DESC =
1882 new TField("success", TType.STRUCT, (short) 0);
1883
1884 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
1885 new HashMap<Class<? extends IScheme>, SchemeFactory>();
1886
1887 static {
1888 schemes.put(StandardScheme.class,
1889 new infoTransferQuery_resultStandardSchemeFactory());
1890 schemes.put(TupleScheme.class,
1891 new infoTransferQuery_resultTupleSchemeFactory());
1892 }
1893
1894 private R66Result success;
1895
1896
1897
1898
1899
1900
1901 public enum _Fields implements TFieldIdEnum {
1902 SUCCESS((short) 0, SUCCESS3);
1903
1904 private static final Map<String, _Fields> byName =
1905 new HashMap<String, _Fields>();
1906
1907 static {
1908 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
1909 byName.put(field.getFieldName(), field);
1910 }
1911 }
1912
1913
1914
1915
1916
1917
1918 public static _Fields findByThriftId(final int fieldId) {
1919 if (fieldId == 0) {
1920 return SUCCESS;
1921 }
1922 return null;
1923 }
1924
1925
1926
1927
1928
1929
1930 public static _Fields findByThriftIdOrThrow(final int fieldId) {
1931 final _Fields fields = findByThriftId(fieldId);
1932 if (fields == null) {
1933 throw new IllegalArgumentException(
1934 "Field " + fieldId + " doesn't exist!");
1935 }
1936 return fields;
1937 }
1938
1939
1940
1941
1942
1943 public static _Fields findByName(final String name) {
1944 return byName.get(name);
1945 }
1946
1947 private final short thriftId;
1948 private final String fieldName;
1949
1950 _Fields(final short thriftId, final String fieldName) {
1951 this.thriftId = thriftId;
1952 this.fieldName = fieldName;
1953 }
1954
1955 @Override
1956 public final short getThriftFieldId() {
1957 return thriftId;
1958 }
1959
1960 @Override
1961 public final String getFieldName() {
1962 return fieldName;
1963 }
1964 }
1965
1966
1967 public static final Map<_Fields, FieldMetaData> metaDataMap;
1968
1969 static {
1970 final Map<_Fields, FieldMetaData> tmpMap =
1971 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
1972 tmpMap.put(_Fields.SUCCESS,
1973 new FieldMetaData("success", TFieldRequirementType.DEFAULT,
1974 new StructMetaData(TType.STRUCT,
1975 R66Result.class)));
1976 metaDataMap = Collections.unmodifiableMap(tmpMap);
1977 FieldMetaData.addStructMetaDataMap(infoTransferQuery_result.class,
1978 metaDataMap);
1979 }
1980
1981 public infoTransferQuery_result() {
1982 }
1983
1984 public infoTransferQuery_result(final R66Result success) {
1985 this();
1986 this.success = success;
1987 }
1988
1989
1990
1991
1992 public infoTransferQuery_result(final infoTransferQuery_result other) {
1993 if (other.isSetSuccess()) {
1994 success = new R66Result(other.success);
1995 }
1996 }
1997
1998 @Override
1999 public final infoTransferQuery_result deepCopy() {
2000 return new infoTransferQuery_result(this);
2001 }
2002
2003 @Override
2004 public final void clear() {
2005 success = null;
2006 }
2007
2008 public final R66Result getSuccess() {
2009 return success;
2010 }
2011
2012 public final infoTransferQuery_result setSuccess(final R66Result success) {
2013 this.success = success;
2014 return this;
2015 }
2016
2017 public final void unsetSuccess() {
2018 success = null;
2019 }
2020
2021
2022
2023
2024
2025 public final boolean isSetSuccess() {
2026 return success != null;
2027 }
2028
2029 public final void setSuccessIsSet(final boolean value) {
2030 if (!value) {
2031 success = null;
2032 }
2033 }
2034
2035 @Override
2036 public final void setFieldValue(final _Fields field, final Object value) {
2037 if (field == _Fields.SUCCESS) {
2038 if (value == null) {
2039 unsetSuccess();
2040 } else {
2041 setSuccess((R66Result) value);
2042 }
2043 }
2044 }
2045
2046 @Override
2047 public final Object getFieldValue(final _Fields field) {
2048 if (field == _Fields.SUCCESS) {
2049 return getSuccess();
2050 }
2051 throw new IllegalStateException();
2052 }
2053
2054
2055
2056
2057
2058
2059 @Override
2060 public final boolean isSet(final _Fields field) {
2061 if (field == null) {
2062 throw new IllegalArgumentException();
2063 }
2064
2065 if (field == _Fields.SUCCESS) {
2066 return isSetSuccess();
2067 }
2068 throw new IllegalStateException();
2069 }
2070
2071 @Override
2072 public final boolean equals(final Object that) {
2073 if (that == null) {
2074 return false;
2075 }
2076 if (that instanceof infoTransferQuery_result) {
2077 return equals((infoTransferQuery_result) that);
2078 }
2079 return false;
2080 }
2081
2082 public final boolean equals(final infoTransferQuery_result that) {
2083 if (that == null) {
2084 return false;
2085 }
2086
2087 final boolean this_present_success = isSetSuccess();
2088 final boolean that_present_success = that.isSetSuccess();
2089 if (this_present_success || that_present_success) {
2090 if (!(this_present_success && that_present_success)) {
2091 return false;
2092 }
2093 return success.equals(that.success);
2094 }
2095
2096 return true;
2097 }
2098
2099 @Override
2100 public final int hashCode() {
2101 return 0;
2102 }
2103
2104 @Override
2105 public final int compareTo(final infoTransferQuery_result other) {
2106 if (!getClass().equals(other.getClass())) {
2107 return getClass().getName().compareTo(other.getClass().getName());
2108 }
2109
2110 int lastComparison;
2111
2112 lastComparison =
2113 Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
2114 if (lastComparison != 0) {
2115 return lastComparison;
2116 }
2117 if (isSetSuccess()) {
2118 lastComparison = TBaseHelper.compareTo(success, other.success);
2119 return lastComparison;
2120 }
2121 return 0;
2122 }
2123
2124 @Override
2125 public final _Fields fieldForId(final int fieldId) {
2126 return _Fields.findByThriftId(fieldId);
2127 }
2128
2129 @Override
2130 public final void read(final TProtocol iprot) throws TException {
2131 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2132 }
2133
2134 @Override
2135 public final void write(final TProtocol oprot) throws TException {
2136 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2137 }
2138
2139 @Override
2140 public final String toString() {
2141 final StringBuilder sb = new StringBuilder("infoTransferQuery_result(");
2142 sb.append("success:");
2143 if (success == null) {
2144 sb.append("null");
2145 } else {
2146 sb.append(success);
2147 }
2148 sb.append(')');
2149 return sb.toString();
2150 }
2151
2152 public final void validate() throws TException {
2153
2154
2155 if (success != null) {
2156 success.validate();
2157 }
2158 }
2159
2160 private void writeObject(final ObjectOutputStream out) throws IOException {
2161 try {
2162 write(new TCompactProtocol(new TIOStreamTransport(out)));
2163 } catch (final TException te) {
2164 throw new IOException(te);
2165 }
2166 }
2167
2168 private void readObject(final ObjectInputStream in)
2169 throws IOException, ClassNotFoundException {
2170 try {
2171 read(new TCompactProtocol(new TIOStreamTransport(in)));
2172 } catch (final TException te) {
2173 throw new IOException(te);
2174 }
2175 }
2176
2177 private static class infoTransferQuery_resultStandardSchemeFactory
2178 implements SchemeFactory {
2179 @Override
2180 public final infoTransferQuery_resultStandardScheme getScheme() {
2181 return new infoTransferQuery_resultStandardScheme();
2182 }
2183 }
2184
2185 private static class infoTransferQuery_resultStandardScheme
2186 extends StandardScheme<infoTransferQuery_result> {
2187
2188 @Override
2189 public final void read(final TProtocol iprot,
2190 final infoTransferQuery_result struct)
2191 throws TException {
2192 TField schemeField;
2193 iprot.readStructBegin();
2194 while (true) {
2195 schemeField = iprot.readFieldBegin();
2196 if (schemeField.type == TType.STOP) {
2197 break;
2198 }
2199 if (schemeField.id == 0) {
2200 if (schemeField.type == TType.STRUCT) {
2201 struct.success = new R66Result();
2202 struct.success.read(iprot);
2203 struct.setSuccessIsSet(true);
2204 } else {
2205 TProtocolUtil.skip(iprot, schemeField.type);
2206 }
2207 } else {
2208 TProtocolUtil.skip(iprot, schemeField.type);
2209 }
2210 iprot.readFieldEnd();
2211 }
2212 iprot.readStructEnd();
2213
2214
2215
2216 struct.validate();
2217 }
2218
2219 @Override
2220 public final void write(final TProtocol oprot,
2221 final infoTransferQuery_result struct)
2222 throws TException {
2223 struct.validate();
2224
2225 oprot.writeStructBegin(STRUCT_DESC);
2226 if (struct.success != null) {
2227 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
2228 struct.success.write(oprot);
2229 oprot.writeFieldEnd();
2230 }
2231 oprot.writeFieldStop();
2232 oprot.writeStructEnd();
2233 }
2234
2235 }
2236
2237 private static class infoTransferQuery_resultTupleSchemeFactory
2238 implements SchemeFactory {
2239 @Override
2240 public final infoTransferQuery_resultTupleScheme getScheme() {
2241 return new infoTransferQuery_resultTupleScheme();
2242 }
2243 }
2244
2245 private static class infoTransferQuery_resultTupleScheme
2246 extends TupleScheme<infoTransferQuery_result> {
2247
2248 @Override
2249 public final void write(final TProtocol prot,
2250 final infoTransferQuery_result struct)
2251 throws TException {
2252 final TTupleProtocol oprot = (TTupleProtocol) prot;
2253 final BitSet optionals = new BitSet();
2254 if (struct.isSetSuccess()) {
2255 optionals.set(0);
2256 }
2257 oprot.writeBitSet(optionals, 1);
2258 if (struct.isSetSuccess()) {
2259 struct.success.write(oprot);
2260 }
2261 }
2262
2263 @Override
2264 public final void read(final TProtocol prot,
2265 final infoTransferQuery_result struct)
2266 throws TException {
2267 final TTupleProtocol iprot = (TTupleProtocol) prot;
2268 final BitSet incoming = iprot.readBitSet(1);
2269 if (incoming.get(0)) {
2270 struct.success = new R66Result();
2271 struct.success.read(iprot);
2272 struct.setSuccessIsSet(true);
2273 }
2274 }
2275 }
2276
2277 }
2278
2279 public static class isStillRunning_args
2280 implements TBase<isStillRunning_args, isStillRunning_args._Fields>,
2281 Cloneable {
2282 private static final String TOUID2 = "touid";
2283
2284 private static final String FROMUID2 = "fromuid";
2285
2286
2287
2288
2289 private static final long serialVersionUID = -8778878918458740258L;
2290
2291 private static final TStruct STRUCT_DESC =
2292 new TStruct("isStillRunning_args");
2293
2294 private static final TField FROMUID_FIELD_DESC =
2295 new TField(FROMUID2, TType.STRING, (short) 1);
2296 private static final TField TOUID_FIELD_DESC =
2297 new TField(TOUID2, TType.STRING, (short) 2);
2298 private static final TField TID_FIELD_DESC =
2299 new TField("tid", TType.I64, (short) 3);
2300
2301 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
2302 new HashMap<Class<? extends IScheme>, SchemeFactory>();
2303
2304 static {
2305 schemes.put(StandardScheme.class,
2306 new isStillRunning_argsStandardSchemeFactory());
2307 schemes.put(TupleScheme.class,
2308 new isStillRunning_argsTupleSchemeFactory());
2309 }
2310
2311 private String fromuid;
2312 private String touid;
2313 private long tid;
2314
2315 @Override
2316 public final isStillRunning_args clone() throws CloneNotSupportedException {
2317 return (isStillRunning_args) super.clone();
2318 }
2319
2320
2321
2322
2323
2324
2325 public enum _Fields implements TFieldIdEnum {
2326 FROMUID((short) 1, FROMUID2), TOUID((short) 2, TOUID2),
2327 TID((short) 3, "tid");
2328
2329 private static final Map<String, _Fields> byName =
2330 new HashMap<String, _Fields>();
2331
2332 static {
2333 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
2334 byName.put(field.getFieldName(), field);
2335 }
2336 }
2337
2338
2339
2340
2341
2342
2343 public static _Fields findByThriftId(final int fieldId) {
2344 switch (fieldId) {
2345 case 1:
2346 return FROMUID;
2347 case 2:
2348 return TOUID;
2349 case 3:
2350 return TID;
2351 default:
2352 return null;
2353 }
2354 }
2355
2356
2357
2358
2359
2360
2361 public static _Fields findByThriftIdOrThrow(final int fieldId) {
2362 final _Fields fields = findByThriftId(fieldId);
2363 if (fields == null) {
2364 throw new IllegalArgumentException(
2365 "Field " + fieldId + " doesn't exist!");
2366 }
2367 return fields;
2368 }
2369
2370
2371
2372
2373
2374 public static _Fields findByName(final String name) {
2375 return byName.get(name);
2376 }
2377
2378 private final short thriftId;
2379 private final String fieldName;
2380
2381 _Fields(final short thriftId, final String fieldName) {
2382 this.thriftId = thriftId;
2383 this.fieldName = fieldName;
2384 }
2385
2386 @Override
2387 public final short getThriftFieldId() {
2388 return thriftId;
2389 }
2390
2391 @Override
2392 public final String getFieldName() {
2393 return fieldName;
2394 }
2395 }
2396
2397
2398 private static final int TID_ISSET_ID = 0;
2399 private byte issetBitfield;
2400 public static final Map<_Fields, FieldMetaData> metaDataMap;
2401
2402 static {
2403 final Map<_Fields, FieldMetaData> tmpMap =
2404 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
2405 tmpMap.put(_Fields.FROMUID,
2406 new FieldMetaData(FROMUID2, TFieldRequirementType.DEFAULT,
2407 new FieldValueMetaData(TType.STRING)));
2408 tmpMap.put(_Fields.TOUID,
2409 new FieldMetaData(TOUID2, TFieldRequirementType.DEFAULT,
2410 new FieldValueMetaData(TType.STRING)));
2411 tmpMap.put(_Fields.TID,
2412 new FieldMetaData("tid", TFieldRequirementType.DEFAULT,
2413 new FieldValueMetaData(TType.I64)));
2414 metaDataMap = Collections.unmodifiableMap(tmpMap);
2415 FieldMetaData.addStructMetaDataMap(isStillRunning_args.class,
2416 metaDataMap);
2417 }
2418
2419 public isStillRunning_args() {
2420 }
2421
2422 public isStillRunning_args(final String fromuid, final String touid,
2423 final long tid) {
2424 this();
2425 this.fromuid = fromuid;
2426 this.touid = touid;
2427 this.tid = tid;
2428 setTidIsSet(true);
2429 }
2430
2431
2432
2433
2434 public isStillRunning_args(final isStillRunning_args other) {
2435 issetBitfield = other.issetBitfield;
2436 if (other.isSetFromuid()) {
2437 fromuid = other.fromuid;
2438 }
2439 if (other.isSetTouid()) {
2440 touid = other.touid;
2441 }
2442 tid = other.tid;
2443 }
2444
2445 @Override
2446 public final isStillRunning_args deepCopy() {
2447 return new isStillRunning_args(this);
2448 }
2449
2450 @Override
2451 public final void clear() {
2452 fromuid = null;
2453 touid = null;
2454 setTidIsSet(false);
2455 tid = 0;
2456 }
2457
2458 public final String getFromuid() {
2459 return fromuid;
2460 }
2461
2462 public final isStillRunning_args setFromuid(final String fromuid) {
2463 this.fromuid = fromuid;
2464 return this;
2465 }
2466
2467 public final void unsetFromuid() {
2468 fromuid = null;
2469 }
2470
2471
2472
2473
2474
2475 public final boolean isSetFromuid() {
2476 return fromuid != null;
2477 }
2478
2479 public final void setFromuidIsSet(final boolean value) {
2480 if (!value) {
2481 fromuid = null;
2482 }
2483 }
2484
2485 public final String getTouid() {
2486 return touid;
2487 }
2488
2489 public final isStillRunning_args setTouid(final String touid) {
2490 this.touid = touid;
2491 return this;
2492 }
2493
2494 public final void unsetTouid() {
2495 touid = null;
2496 }
2497
2498
2499
2500
2501
2502
2503 public final boolean isSetTouid() {
2504 return touid != null;
2505 }
2506
2507 public final void setTouidIsSet(final boolean value) {
2508 if (!value) {
2509 touid = null;
2510 }
2511 }
2512
2513 public final long getTid() {
2514 return tid;
2515 }
2516
2517 public final isStillRunning_args setTid(final long tid) {
2518 this.tid = tid;
2519 setTidIsSet(true);
2520 return this;
2521 }
2522
2523 public final void unsetTid() {
2524 issetBitfield = EncodingUtils.clearBit(issetBitfield, TID_ISSET_ID);
2525 }
2526
2527
2528
2529
2530
2531
2532 public final boolean isSetTid() {
2533 return EncodingUtils.testBit(issetBitfield, TID_ISSET_ID);
2534 }
2535
2536 public final void setTidIsSet(final boolean value) {
2537 issetBitfield = EncodingUtils.setBit(issetBitfield, TID_ISSET_ID, value);
2538 }
2539
2540 @Override
2541 public final void setFieldValue(final _Fields field, final Object value) {
2542 switch (field) {
2543 case FROMUID:
2544 if (value == null) {
2545 unsetFromuid();
2546 } else {
2547 setFromuid((String) value);
2548 }
2549 break;
2550
2551 case TOUID:
2552 if (value == null) {
2553 unsetTouid();
2554 } else {
2555 setTouid((String) value);
2556 }
2557 break;
2558
2559 case TID:
2560 if (value == null) {
2561 unsetTid();
2562 } else {
2563 setTid((Long) value);
2564 }
2565 break;
2566
2567 }
2568 }
2569
2570 @Override
2571 public final Object getFieldValue(final _Fields field) {
2572 switch (field) {
2573 case FROMUID:
2574 return getFromuid();
2575
2576 case TOUID:
2577 return getTouid();
2578
2579 case TID:
2580 return Long.valueOf(getTid());
2581
2582 }
2583 throw new IllegalStateException();
2584 }
2585
2586
2587
2588
2589
2590
2591 @Override
2592 public final boolean isSet(final _Fields field) {
2593 if (field == null) {
2594 throw new IllegalArgumentException();
2595 }
2596
2597 switch (field) {
2598 case FROMUID:
2599 return isSetFromuid();
2600 case TOUID:
2601 return isSetTouid();
2602 case TID:
2603 return isSetTid();
2604 }
2605 throw new IllegalStateException();
2606 }
2607
2608 @Override
2609 public final boolean equals(final Object that) {
2610 if (that == null) {
2611 return false;
2612 }
2613 if (that instanceof isStillRunning_args) {
2614 return equals((isStillRunning_args) that);
2615 }
2616 return false;
2617 }
2618
2619 public final boolean equals(final isStillRunning_args that) {
2620 if (that == null) {
2621 return false;
2622 }
2623
2624 final boolean this_present_fromuid = isSetFromuid();
2625 final boolean that_present_fromuid = that.isSetFromuid();
2626 if (this_present_fromuid || that_present_fromuid) {
2627 if (!(this_present_fromuid && that_present_fromuid)) {
2628 return false;
2629 }
2630 if (!fromuid.equals(that.fromuid)) {
2631 return false;
2632 }
2633 }
2634
2635 final boolean this_present_touid = isSetTouid();
2636 final boolean that_present_touid = that.isSetTouid();
2637 if (this_present_touid || that_present_touid) {
2638 if (!(this_present_touid && that_present_touid)) {
2639 return false;
2640 }
2641 if (!touid.equals(that.touid)) {
2642 return false;
2643 }
2644 }
2645
2646 return tid == that.tid;
2647 }
2648
2649 @Override
2650 public final int hashCode() {
2651 return 0;
2652 }
2653
2654 @Override
2655 public final int compareTo(final isStillRunning_args other) {
2656 if (!getClass().equals(other.getClass())) {
2657 return getClass().getName().compareTo(other.getClass().getName());
2658 }
2659
2660 int lastComparison;
2661
2662 lastComparison =
2663 Boolean.valueOf(isSetFromuid()).compareTo(other.isSetFromuid());
2664 if (lastComparison != 0) {
2665 return lastComparison;
2666 }
2667 if (isSetFromuid()) {
2668 lastComparison = TBaseHelper.compareTo(fromuid, other.fromuid);
2669 if (lastComparison != 0) {
2670 return lastComparison;
2671 }
2672 }
2673 lastComparison =
2674 Boolean.valueOf(isSetTouid()).compareTo(other.isSetTouid());
2675 if (lastComparison != 0) {
2676 return lastComparison;
2677 }
2678 if (isSetTouid()) {
2679 lastComparison = TBaseHelper.compareTo(touid, other.touid);
2680 if (lastComparison != 0) {
2681 return lastComparison;
2682 }
2683 }
2684 lastComparison = Boolean.valueOf(isSetTid()).compareTo(other.isSetTid());
2685 if (lastComparison != 0) {
2686 return lastComparison;
2687 }
2688 if (isSetTid()) {
2689 lastComparison = TBaseHelper.compareTo(tid, other.tid);
2690 return lastComparison;
2691 }
2692 return 0;
2693 }
2694
2695 @Override
2696 public final _Fields fieldForId(final int fieldId) {
2697 return _Fields.findByThriftId(fieldId);
2698 }
2699
2700 @Override
2701 public final void read(final TProtocol iprot) throws TException {
2702 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
2703 }
2704
2705 @Override
2706 public final void write(final TProtocol oprot) throws TException {
2707 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
2708 }
2709
2710 @Override
2711 public final String toString() {
2712 final StringBuilder sb = new StringBuilder("isStillRunning_args(");
2713
2714 sb.append("fromuid:");
2715 if (fromuid == null) {
2716 sb.append("null");
2717 } else {
2718 sb.append(fromuid);
2719 }
2720 sb.append(", ");
2721 sb.append("touid:");
2722 if (touid == null) {
2723 sb.append("null");
2724 } else {
2725 sb.append(touid);
2726 }
2727 sb.append(", ");
2728 sb.append("tid:").append(tid);
2729 sb.append(')');
2730 return sb.toString();
2731 }
2732
2733 public final void validate() throws TException {
2734
2735
2736 }
2737
2738 private void writeObject(final ObjectOutputStream out) throws IOException {
2739 try {
2740 write(new TCompactProtocol(new TIOStreamTransport(out)));
2741 } catch (final TException te) {
2742 throw new IOException(te);
2743 }
2744 }
2745
2746 private void readObject(final ObjectInputStream in)
2747 throws IOException, ClassNotFoundException {
2748 try {
2749
2750
2751 issetBitfield = 0;
2752 read(new TCompactProtocol(new TIOStreamTransport(in)));
2753 } catch (final TException te) {
2754 throw new IOException(te);
2755 }
2756 }
2757
2758 private static class isStillRunning_argsStandardSchemeFactory
2759 implements SchemeFactory {
2760 @Override
2761 public final isStillRunning_argsStandardScheme getScheme() {
2762 return new isStillRunning_argsStandardScheme();
2763 }
2764 }
2765
2766 private static class isStillRunning_argsStandardScheme
2767 extends StandardScheme<isStillRunning_args> {
2768
2769 @Override
2770 public final void read(final TProtocol iprot,
2771 final isStillRunning_args struct)
2772 throws TException {
2773 TField schemeField;
2774 iprot.readStructBegin();
2775 while (true) {
2776 schemeField = iprot.readFieldBegin();
2777 if (schemeField.type == TType.STOP) {
2778 break;
2779 }
2780 switch (schemeField.id) {
2781 case 1:
2782 if (schemeField.type == TType.STRING) {
2783 struct.fromuid = iprot.readString();
2784 struct.setFromuidIsSet(true);
2785 } else {
2786 TProtocolUtil.skip(iprot, schemeField.type);
2787 }
2788 break;
2789 case 2:
2790 if (schemeField.type == TType.STRING) {
2791 struct.touid = iprot.readString();
2792 struct.setTouidIsSet(true);
2793 } else {
2794 TProtocolUtil.skip(iprot, schemeField.type);
2795 }
2796 break;
2797 case 3:
2798 if (schemeField.type == TType.I64) {
2799 struct.tid = iprot.readI64();
2800 struct.setTidIsSet(true);
2801 } else {
2802 TProtocolUtil.skip(iprot, schemeField.type);
2803 }
2804 break;
2805 default:
2806 TProtocolUtil.skip(iprot, schemeField.type);
2807 }
2808 iprot.readFieldEnd();
2809 }
2810 iprot.readStructEnd();
2811
2812
2813
2814 struct.validate();
2815 }
2816
2817 @Override
2818 public final void write(final TProtocol oprot,
2819 final isStillRunning_args struct)
2820 throws TException {
2821 struct.validate();
2822
2823 oprot.writeStructBegin(STRUCT_DESC);
2824 if (struct.fromuid != null) {
2825 oprot.writeFieldBegin(FROMUID_FIELD_DESC);
2826 oprot.writeString(struct.fromuid);
2827 oprot.writeFieldEnd();
2828 }
2829 if (struct.touid != null) {
2830 oprot.writeFieldBegin(TOUID_FIELD_DESC);
2831 oprot.writeString(struct.touid);
2832 oprot.writeFieldEnd();
2833 }
2834 oprot.writeFieldBegin(TID_FIELD_DESC);
2835 oprot.writeI64(struct.tid);
2836 oprot.writeFieldEnd();
2837 oprot.writeFieldStop();
2838 oprot.writeStructEnd();
2839 }
2840
2841 }
2842
2843 private static class isStillRunning_argsTupleSchemeFactory
2844 implements SchemeFactory {
2845 @Override
2846 public final isStillRunning_argsTupleScheme getScheme() {
2847 return new isStillRunning_argsTupleScheme();
2848 }
2849 }
2850
2851 private static class isStillRunning_argsTupleScheme
2852 extends TupleScheme<isStillRunning_args> {
2853
2854 @Override
2855 public final void write(final TProtocol prot,
2856 final isStillRunning_args struct)
2857 throws TException {
2858 final TTupleProtocol oprot = (TTupleProtocol) prot;
2859 final BitSet optionals = new BitSet();
2860 if (struct.isSetFromuid()) {
2861 optionals.set(0);
2862 }
2863 if (struct.isSetTouid()) {
2864 optionals.set(1);
2865 }
2866 if (struct.isSetTid()) {
2867 optionals.set(2);
2868 }
2869 oprot.writeBitSet(optionals, 3);
2870 if (struct.isSetFromuid()) {
2871 oprot.writeString(struct.fromuid);
2872 }
2873 if (struct.isSetTouid()) {
2874 oprot.writeString(struct.touid);
2875 }
2876 if (struct.isSetTid()) {
2877 oprot.writeI64(struct.tid);
2878 }
2879 }
2880
2881 @Override
2882 public final void read(final TProtocol prot,
2883 final isStillRunning_args struct)
2884 throws TException {
2885 final TTupleProtocol iprot = (TTupleProtocol) prot;
2886 final BitSet incoming = iprot.readBitSet(3);
2887 if (incoming.get(0)) {
2888 struct.fromuid = iprot.readString();
2889 struct.setFromuidIsSet(true);
2890 }
2891 if (incoming.get(1)) {
2892 struct.touid = iprot.readString();
2893 struct.setTouidIsSet(true);
2894 }
2895 if (incoming.get(2)) {
2896 struct.tid = iprot.readI64();
2897 struct.setTidIsSet(true);
2898 }
2899 }
2900 }
2901
2902 }
2903
2904 public static class isStillRunning_result
2905 implements TBase<isStillRunning_result, isStillRunning_result._Fields>,
2906 Cloneable {
2907
2908
2909
2910 private static final long serialVersionUID = -6399182854596850272L;
2911
2912 private static final TStruct STRUCT_DESC =
2913 new TStruct("isStillRunning_result");
2914
2915 private static final TField SUCCESS_FIELD_DESC =
2916 new TField("success", TType.BOOL, (short) 0);
2917
2918 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
2919 new HashMap<Class<? extends IScheme>, SchemeFactory>();
2920
2921 static {
2922 schemes.put(StandardScheme.class,
2923 new isStillRunning_resultStandardSchemeFactory());
2924 schemes.put(TupleScheme.class,
2925 new isStillRunning_resultTupleSchemeFactory());
2926 }
2927
2928 private boolean success;
2929
2930 @Override
2931 public final isStillRunning_result clone()
2932 throws CloneNotSupportedException {
2933 return (isStillRunning_result) super.clone();
2934 }
2935
2936
2937
2938
2939
2940
2941 public enum _Fields implements TFieldIdEnum {
2942 SUCCESS((short) 0, SUCCESS3);
2943
2944 private static final Map<String, _Fields> byName =
2945 new HashMap<String, _Fields>();
2946
2947 static {
2948 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
2949 byName.put(field.getFieldName(), field);
2950 }
2951 }
2952
2953
2954
2955
2956
2957
2958 public static _Fields findByThriftId(final int fieldId) {
2959 if (fieldId == 0) {
2960 return SUCCESS;
2961 }
2962 return null;
2963 }
2964
2965
2966
2967
2968
2969
2970 public static _Fields findByThriftIdOrThrow(final int fieldId) {
2971 final _Fields fields = findByThriftId(fieldId);
2972 if (fields == null) {
2973 throw new IllegalArgumentException(
2974 "Field " + fieldId + " doesn't exist!");
2975 }
2976 return fields;
2977 }
2978
2979
2980
2981
2982
2983 public static _Fields findByName(final String name) {
2984 return byName.get(name);
2985 }
2986
2987 private final short thriftId;
2988 private final String fieldName;
2989
2990 _Fields(final short thriftId, final String fieldName) {
2991 this.thriftId = thriftId;
2992 this.fieldName = fieldName;
2993 }
2994
2995 @Override
2996 public final short getThriftFieldId() {
2997 return thriftId;
2998 }
2999
3000 @Override
3001 public final String getFieldName() {
3002 return fieldName;
3003 }
3004 }
3005
3006
3007 private static final int SUCCESS_ISSET_ID = 0;
3008 private byte issetBitfield;
3009 public static final Map<_Fields, FieldMetaData> metaDataMap;
3010
3011 static {
3012 final Map<_Fields, FieldMetaData> tmpMap =
3013 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
3014 tmpMap.put(_Fields.SUCCESS,
3015 new FieldMetaData("success", TFieldRequirementType.DEFAULT,
3016 new FieldValueMetaData(TType.BOOL)));
3017 metaDataMap = Collections.unmodifiableMap(tmpMap);
3018 FieldMetaData.addStructMetaDataMap(isStillRunning_result.class,
3019 metaDataMap);
3020 }
3021
3022 public isStillRunning_result() {
3023 }
3024
3025 public isStillRunning_result(final boolean success) {
3026 this();
3027 this.success = success;
3028 setSuccessIsSet(true);
3029 }
3030
3031
3032
3033
3034 public isStillRunning_result(final isStillRunning_result other) {
3035 issetBitfield = other.issetBitfield;
3036 success = other.success;
3037 }
3038
3039 @Override
3040 public final isStillRunning_result deepCopy() {
3041 return new isStillRunning_result(this);
3042 }
3043
3044 @Override
3045 public final void clear() {
3046 setSuccessIsSet(false);
3047 success = false;
3048 }
3049
3050 public final boolean isSuccess() {
3051 return success;
3052 }
3053
3054 public final isStillRunning_result setSuccess(final boolean success) {
3055 this.success = success;
3056 setSuccessIsSet(true);
3057 return this;
3058 }
3059
3060 public final void unsetSuccess() {
3061 issetBitfield = EncodingUtils.clearBit(issetBitfield, SUCCESS_ISSET_ID);
3062 }
3063
3064
3065
3066
3067
3068 public final boolean isSetSuccess() {
3069 return EncodingUtils.testBit(issetBitfield, SUCCESS_ISSET_ID);
3070 }
3071
3072 public final void setSuccessIsSet(final boolean value) {
3073 issetBitfield =
3074 EncodingUtils.setBit(issetBitfield, SUCCESS_ISSET_ID, value);
3075 }
3076
3077 @Override
3078 public final void setFieldValue(final _Fields field, final Object value) {
3079 if (field == _Fields.SUCCESS) {
3080 if (value == null) {
3081 unsetSuccess();
3082 } else {
3083 setSuccess((Boolean) value);
3084 }
3085 }
3086 }
3087
3088 @Override
3089 public final Object getFieldValue(final _Fields field) {
3090 if (field == _Fields.SUCCESS) {
3091 return Boolean.valueOf(isSuccess());
3092 }
3093 throw new IllegalStateException();
3094 }
3095
3096
3097
3098
3099
3100
3101 @Override
3102 public final boolean isSet(final _Fields field) {
3103 if (field == null) {
3104 throw new IllegalArgumentException();
3105 }
3106
3107 if (field == _Fields.SUCCESS) {
3108 return isSetSuccess();
3109 }
3110 throw new IllegalStateException();
3111 }
3112
3113 @Override
3114 public final boolean equals(final Object that) {
3115 if (that == null) {
3116 return false;
3117 }
3118 if (that instanceof isStillRunning_result) {
3119 return equals((isStillRunning_result) that);
3120 }
3121 return false;
3122 }
3123
3124 public final boolean equals(final isStillRunning_result that) {
3125 if (that == null) {
3126 return false;
3127 }
3128 return success == that.success;
3129 }
3130
3131 @Override
3132 public final int hashCode() {
3133 return 0;
3134 }
3135
3136 @Override
3137 public final int compareTo(final isStillRunning_result other) {
3138 if (!getClass().equals(other.getClass())) {
3139 return getClass().getName().compareTo(other.getClass().getName());
3140 }
3141
3142 int lastComparison;
3143
3144 lastComparison =
3145 Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
3146 if (lastComparison != 0) {
3147 return lastComparison;
3148 }
3149 if (isSetSuccess()) {
3150 lastComparison = TBaseHelper.compareTo(success, other.success);
3151 return lastComparison;
3152 }
3153 return 0;
3154 }
3155
3156 @Override
3157 public final _Fields fieldForId(final int fieldId) {
3158 return _Fields.findByThriftId(fieldId);
3159 }
3160
3161 @Override
3162 public final void read(final TProtocol iprot) throws TException {
3163 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3164 }
3165
3166 @Override
3167 public final void write(final TProtocol oprot) throws TException {
3168 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3169 }
3170
3171 @Override
3172 public final String toString() {
3173 final StringBuilder sb = new StringBuilder("isStillRunning_result(");
3174 sb.append("success:").append(success);
3175 sb.append(')');
3176 return sb.toString();
3177 }
3178
3179 public final void validate() throws TException {
3180
3181
3182 }
3183
3184 private void writeObject(final ObjectOutputStream out) throws IOException {
3185 try {
3186 write(new TCompactProtocol(new TIOStreamTransport(out)));
3187 } catch (final TException te) {
3188 throw new IOException(te);
3189 }
3190 }
3191
3192 private void readObject(final ObjectInputStream in)
3193 throws IOException, ClassNotFoundException {
3194 try {
3195
3196
3197 issetBitfield = 0;
3198 read(new TCompactProtocol(new TIOStreamTransport(in)));
3199 } catch (final TException te) {
3200 throw new IOException(te);
3201 }
3202 }
3203
3204 private static class isStillRunning_resultStandardSchemeFactory
3205 implements SchemeFactory {
3206 @Override
3207 public final isStillRunning_resultStandardScheme getScheme() {
3208 return new isStillRunning_resultStandardScheme();
3209 }
3210 }
3211
3212 private static class isStillRunning_resultStandardScheme
3213 extends StandardScheme<isStillRunning_result> {
3214
3215 @Override
3216 public final void read(final TProtocol iprot,
3217 final isStillRunning_result struct)
3218 throws TException {
3219 TField schemeField;
3220 iprot.readStructBegin();
3221 while (true) {
3222 schemeField = iprot.readFieldBegin();
3223 if (schemeField.type == TType.STOP) {
3224 break;
3225 }
3226 if (schemeField.id == 0) {
3227 if (schemeField.type == TType.BOOL) {
3228 struct.success = iprot.readBool();
3229 struct.setSuccessIsSet(true);
3230 } else {
3231 TProtocolUtil.skip(iprot, schemeField.type);
3232 }
3233 } else {
3234 TProtocolUtil.skip(iprot, schemeField.type);
3235 }
3236 iprot.readFieldEnd();
3237 }
3238 iprot.readStructEnd();
3239
3240
3241
3242 struct.validate();
3243 }
3244
3245 @Override
3246 public final void write(final TProtocol oprot,
3247 final isStillRunning_result struct)
3248 throws TException {
3249 struct.validate();
3250
3251 oprot.writeStructBegin(STRUCT_DESC);
3252 if (struct.isSetSuccess()) {
3253 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
3254 oprot.writeBool(struct.success);
3255 oprot.writeFieldEnd();
3256 }
3257 oprot.writeFieldStop();
3258 oprot.writeStructEnd();
3259 }
3260
3261 }
3262
3263 private static class isStillRunning_resultTupleSchemeFactory
3264 implements SchemeFactory {
3265 @Override
3266 public final isStillRunning_resultTupleScheme getScheme() {
3267 return new isStillRunning_resultTupleScheme();
3268 }
3269 }
3270
3271 private static class isStillRunning_resultTupleScheme
3272 extends TupleScheme<isStillRunning_result> {
3273
3274 @Override
3275 public final void write(final TProtocol prot,
3276 final isStillRunning_result struct)
3277 throws TException {
3278 final TTupleProtocol oprot = (TTupleProtocol) prot;
3279 final BitSet optionals = new BitSet();
3280 if (struct.isSetSuccess()) {
3281 optionals.set(0);
3282 }
3283 oprot.writeBitSet(optionals, 1);
3284 if (struct.isSetSuccess()) {
3285 oprot.writeBool(struct.success);
3286 }
3287 }
3288
3289 @Override
3290 public final void read(final TProtocol prot,
3291 final isStillRunning_result struct)
3292 throws TException {
3293 final TTupleProtocol iprot = (TTupleProtocol) prot;
3294 final BitSet incoming = iprot.readBitSet(1);
3295 if (incoming.get(0)) {
3296 struct.success = iprot.readBool();
3297 struct.setSuccessIsSet(true);
3298 }
3299 }
3300 }
3301
3302 }
3303
3304 public static class infoListQuery_args
3305 implements TBase<infoListQuery_args, infoListQuery_args._Fields>,
3306 Cloneable {
3307
3308
3309
3310 private static final long serialVersionUID = -5464335236652979724L;
3311
3312 private static final TStruct STRUCT_DESC =
3313 new TStruct("infoListQuery_args");
3314
3315 private static final TField REQUEST_FIELD_DESC =
3316 new TField("request", TType.STRUCT, (short) 1);
3317
3318 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
3319 new HashMap<Class<? extends IScheme>, SchemeFactory>();
3320
3321 static {
3322 schemes.put(StandardScheme.class,
3323 new infoListQuery_argsStandardSchemeFactory());
3324 schemes.put(TupleScheme.class,
3325 new infoListQuery_argsTupleSchemeFactory());
3326 }
3327
3328 private R66Request request;
3329
3330 @Override
3331 public final infoListQuery_args clone() throws CloneNotSupportedException {
3332 return (infoListQuery_args) super.clone();
3333 }
3334
3335
3336
3337
3338
3339
3340 public enum _Fields implements TFieldIdEnum {
3341 REQUEST((short) 1, REQUEST3);
3342
3343 private static final Map<String, _Fields> byName =
3344 new HashMap<String, _Fields>();
3345
3346 static {
3347 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
3348 byName.put(field.getFieldName(), field);
3349 }
3350 }
3351
3352
3353
3354
3355
3356
3357 public static _Fields findByThriftId(final int fieldId) {
3358 if (fieldId == 1) {
3359 return REQUEST;
3360 }
3361 return null;
3362 }
3363
3364
3365
3366
3367
3368
3369 public static _Fields findByThriftIdOrThrow(final int fieldId) {
3370 final _Fields fields = findByThriftId(fieldId);
3371 if (fields == null) {
3372 throw new IllegalArgumentException(
3373 "Field " + fieldId + " doesn't exist!");
3374 }
3375 return fields;
3376 }
3377
3378
3379
3380
3381
3382 public static _Fields findByName(final String name) {
3383 return byName.get(name);
3384 }
3385
3386 private final short thriftId;
3387 private final String fieldName;
3388
3389 _Fields(final short thriftId, final String fieldName) {
3390 this.thriftId = thriftId;
3391 this.fieldName = fieldName;
3392 }
3393
3394 @Override
3395 public final short getThriftFieldId() {
3396 return thriftId;
3397 }
3398
3399 @Override
3400 public final String getFieldName() {
3401 return fieldName;
3402 }
3403 }
3404
3405
3406 public static final Map<_Fields, FieldMetaData> metaDataMap;
3407
3408 static {
3409 final Map<_Fields, FieldMetaData> tmpMap =
3410 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
3411 tmpMap.put(_Fields.REQUEST,
3412 new FieldMetaData("request", TFieldRequirementType.DEFAULT,
3413 new StructMetaData(TType.STRUCT,
3414 R66Request.class)));
3415 metaDataMap = Collections.unmodifiableMap(tmpMap);
3416 FieldMetaData.addStructMetaDataMap(infoListQuery_args.class, metaDataMap);
3417 }
3418
3419 public infoListQuery_args() {
3420 }
3421
3422 public infoListQuery_args(final R66Request request) {
3423 this();
3424 this.request = request;
3425 }
3426
3427
3428
3429
3430 public infoListQuery_args(final infoListQuery_args other) {
3431 if (other.isSetRequest()) {
3432 request = new R66Request(other.request);
3433 }
3434 }
3435
3436 @Override
3437 public final infoListQuery_args deepCopy() {
3438 return new infoListQuery_args(this);
3439 }
3440
3441 @Override
3442 public final void clear() {
3443 request = null;
3444 }
3445
3446 public final R66Request getRequest() {
3447 return request;
3448 }
3449
3450 public final infoListQuery_args setRequest(final R66Request request) {
3451 this.request = request;
3452 return this;
3453 }
3454
3455 public final void unsetRequest() {
3456 request = null;
3457 }
3458
3459
3460
3461
3462
3463 public final boolean isSetRequest() {
3464 return request != null;
3465 }
3466
3467 public final void setRequestIsSet(final boolean value) {
3468 if (!value) {
3469 request = null;
3470 }
3471 }
3472
3473 @Override
3474 public final void setFieldValue(final _Fields field, final Object value) {
3475 if (field == _Fields.REQUEST) {
3476 if (value == null) {
3477 unsetRequest();
3478 } else {
3479 setRequest((R66Request) value);
3480 }
3481 }
3482 }
3483
3484 @Override
3485 public final Object getFieldValue(final _Fields field) {
3486 if (field == _Fields.REQUEST) {
3487 return getRequest();
3488 }
3489 throw new IllegalStateException();
3490 }
3491
3492
3493
3494
3495
3496
3497 @Override
3498 public final boolean isSet(final _Fields field) {
3499 if (field == null) {
3500 throw new IllegalArgumentException();
3501 }
3502
3503 if (field == _Fields.REQUEST) {
3504 return isSetRequest();
3505 }
3506 throw new IllegalStateException();
3507 }
3508
3509 @Override
3510 public final boolean equals(final Object that) {
3511 if (that == null) {
3512 return false;
3513 }
3514 if (that instanceof infoListQuery_args) {
3515 return equals((infoListQuery_args) that);
3516 }
3517 return false;
3518 }
3519
3520 public final boolean equals(final infoListQuery_args that) {
3521 if (that == null) {
3522 return false;
3523 }
3524
3525 final boolean this_present_request = isSetRequest();
3526 final boolean that_present_request = that.isSetRequest();
3527 if (this_present_request || that_present_request) {
3528 if (!(this_present_request && that_present_request)) {
3529 return false;
3530 }
3531 return request.equals(that.request);
3532 }
3533
3534 return true;
3535 }
3536
3537 @Override
3538 public final int hashCode() {
3539 return 0;
3540 }
3541
3542 @Override
3543 public final int compareTo(final infoListQuery_args other) {
3544 if (!getClass().equals(other.getClass())) {
3545 return getClass().getName().compareTo(other.getClass().getName());
3546 }
3547
3548 int lastComparison;
3549
3550 lastComparison =
3551 Boolean.valueOf(isSetRequest()).compareTo(other.isSetRequest());
3552 if (lastComparison != 0) {
3553 return lastComparison;
3554 }
3555 if (isSetRequest()) {
3556 lastComparison = TBaseHelper.compareTo(request, other.request);
3557 return lastComparison;
3558 }
3559 return 0;
3560 }
3561
3562 @Override
3563 public final _Fields fieldForId(final int fieldId) {
3564 return _Fields.findByThriftId(fieldId);
3565 }
3566
3567 @Override
3568 public final void read(final TProtocol iprot) throws TException {
3569 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
3570 }
3571
3572 @Override
3573 public final void write(final TProtocol oprot) throws TException {
3574 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
3575 }
3576
3577 @Override
3578 public final String toString() {
3579 final StringBuilder sb = new StringBuilder("infoListQuery_args(");
3580 sb.append("request:");
3581 if (request == null) {
3582 sb.append("null");
3583 } else {
3584 sb.append(request);
3585 }
3586 sb.append(')');
3587 return sb.toString();
3588 }
3589
3590 public final void validate() throws TException {
3591
3592
3593 if (request != null) {
3594 request.validate();
3595 }
3596 }
3597
3598 private void writeObject(final ObjectOutputStream out) throws IOException {
3599 try {
3600 write(new TCompactProtocol(new TIOStreamTransport(out)));
3601 } catch (final TException te) {
3602 throw new IOException(te);
3603 }
3604 }
3605
3606 private void readObject(final ObjectInputStream in)
3607 throws IOException, ClassNotFoundException {
3608 try {
3609 read(new TCompactProtocol(new TIOStreamTransport(in)));
3610 } catch (final TException te) {
3611 throw new IOException(te);
3612 }
3613 }
3614
3615 private static class infoListQuery_argsStandardSchemeFactory
3616 implements SchemeFactory {
3617 @Override
3618 public final infoListQuery_argsStandardScheme getScheme() {
3619 return new infoListQuery_argsStandardScheme();
3620 }
3621 }
3622
3623 private static class infoListQuery_argsStandardScheme
3624 extends StandardScheme<infoListQuery_args> {
3625
3626 @Override
3627 public final void read(final TProtocol iprot,
3628 final infoListQuery_args struct)
3629 throws TException {
3630 TField schemeField;
3631 iprot.readStructBegin();
3632 while (true) {
3633 schemeField = iprot.readFieldBegin();
3634 if (schemeField.type == TType.STOP) {
3635 break;
3636 }
3637 if (schemeField.id == 1) {
3638 if (schemeField.type == TType.STRUCT) {
3639 struct.request = new R66Request();
3640 struct.request.read(iprot);
3641 struct.setRequestIsSet(true);
3642 } else {
3643 TProtocolUtil.skip(iprot, schemeField.type);
3644 }
3645 } else {
3646 TProtocolUtil.skip(iprot, schemeField.type);
3647 }
3648 iprot.readFieldEnd();
3649 }
3650 iprot.readStructEnd();
3651
3652
3653
3654 struct.validate();
3655 }
3656
3657 @Override
3658 public final void write(final TProtocol oprot,
3659 final infoListQuery_args struct)
3660 throws TException {
3661 struct.validate();
3662
3663 oprot.writeStructBegin(STRUCT_DESC);
3664 if (struct.request != null) {
3665 oprot.writeFieldBegin(REQUEST_FIELD_DESC);
3666 struct.request.write(oprot);
3667 oprot.writeFieldEnd();
3668 }
3669 oprot.writeFieldStop();
3670 oprot.writeStructEnd();
3671 }
3672
3673 }
3674
3675 private static class infoListQuery_argsTupleSchemeFactory
3676 implements SchemeFactory {
3677 @Override
3678 public final infoListQuery_argsTupleScheme getScheme() {
3679 return new infoListQuery_argsTupleScheme();
3680 }
3681 }
3682
3683 private static class infoListQuery_argsTupleScheme
3684 extends TupleScheme<infoListQuery_args> {
3685
3686 @Override
3687 public final void write(final TProtocol prot,
3688 final infoListQuery_args struct)
3689 throws TException {
3690 final TTupleProtocol oprot = (TTupleProtocol) prot;
3691 final BitSet optionals = new BitSet();
3692 if (struct.isSetRequest()) {
3693 optionals.set(0);
3694 }
3695 oprot.writeBitSet(optionals, 1);
3696 if (struct.isSetRequest()) {
3697 struct.request.write(oprot);
3698 }
3699 }
3700
3701 @Override
3702 public final void read(final TProtocol prot,
3703 final infoListQuery_args struct)
3704 throws TException {
3705 final TTupleProtocol iprot = (TTupleProtocol) prot;
3706 final BitSet incoming = iprot.readBitSet(1);
3707 if (incoming.get(0)) {
3708 struct.request = new R66Request();
3709 struct.request.read(iprot);
3710 struct.setRequestIsSet(true);
3711 }
3712 }
3713 }
3714
3715 }
3716
3717 public static class infoListQuery_result
3718 implements TBase<infoListQuery_result, infoListQuery_result._Fields>,
3719 Cloneable {
3720
3721
3722
3723 private static final long serialVersionUID = 6044365687424384800L;
3724
3725 private static final TStruct STRUCT_DESC =
3726 new TStruct("infoListQuery_result");
3727
3728 private static final TField SUCCESS_FIELD_DESC =
3729 new TField("success", TType.LIST, (short) 0);
3730
3731 private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
3732 new HashMap<Class<? extends IScheme>, SchemeFactory>();
3733
3734 static {
3735 schemes.put(StandardScheme.class,
3736 new infoListQuery_resultStandardSchemeFactory());
3737 schemes.put(TupleScheme.class,
3738 new infoListQuery_resultTupleSchemeFactory());
3739 }
3740
3741 private List<String> success;
3742
3743 @Override
3744 public final infoListQuery_result clone()
3745 throws CloneNotSupportedException {
3746 return (infoListQuery_result) super.clone();
3747 }
3748
3749
3750
3751
3752
3753
3754 public enum _Fields implements TFieldIdEnum {
3755 SUCCESS((short) 0, SUCCESS3);
3756
3757 private static final Map<String, _Fields> byName =
3758 new HashMap<String, _Fields>();
3759
3760 static {
3761 for (final _Fields field : EnumSet.allOf(_Fields.class)) {
3762 byName.put(field.getFieldName(), field);
3763 }
3764 }
3765
3766
3767
3768
3769
3770
3771 public static _Fields findByThriftId(final int fieldId) {
3772 if (fieldId == 0) {
3773 return SUCCESS;
3774 }
3775 return null;
3776 }
3777
3778
3779
3780
3781
3782
3783 public static _Fields findByThriftIdOrThrow(final int fieldId) {
3784 final _Fields fields = findByThriftId(fieldId);
3785 if (fields == null) {
3786 throw new IllegalArgumentException(
3787 "Field " + fieldId + " doesn't exist!");
3788 }
3789 return fields;
3790 }
3791
3792
3793
3794
3795
3796 public static _Fields findByName(final String name) {
3797 return byName.get(name);
3798 }
3799
3800 private final short thriftId;
3801 private final String fieldName;
3802
3803 _Fields(final short thriftId, final String fieldName) {
3804 this.thriftId = thriftId;
3805 this.fieldName = fieldName;
3806 }
3807
3808 @Override
3809 public final short getThriftFieldId() {
3810 return thriftId;
3811 }
3812
3813 @Override
3814 public final String getFieldName() {
3815 return fieldName;
3816 }
3817 }
3818
3819
3820 public static final Map<_Fields, FieldMetaData> metaDataMap;
3821
3822 static {
3823 final Map<_Fields, FieldMetaData> tmpMap =
3824 new EnumMap<_Fields, FieldMetaData>(_Fields.class);
3825 tmpMap.put(_Fields.SUCCESS,
3826 new FieldMetaData("success", TFieldRequirementType.DEFAULT,
3827 new ListMetaData(TType.LIST,
3828 new FieldValueMetaData(
3829 TType.STRING))));
3830 metaDataMap = Collections.unmodifiableMap(tmpMap);
3831 FieldMetaData.addStructMetaDataMap(infoListQuery_result.class,
3832 metaDataMap);
3833 }
3834
3835 public infoListQuery_result() {
3836 }
3837
3838 public infoListQuery_result(final List<String> success) {
3839 this();
3840 this.success = success;
3841 }
3842
3843
3844
3845
3846 public infoListQuery_result(final infoListQuery_result other) {
3847 if (other.isSetSuccess()) {
3848 success = new ArrayList<String>(other.success);
3849 }
3850 }
3851
3852 @Override
3853 public final infoListQuery_result deepCopy() {
3854 return new infoListQuery_result(this);
3855 }
3856
3857 @Override
3858 public final void clear() {
3859 success = null;
3860 }
3861
3862 public final int getSuccessSize() {
3863 return success == null? 0 : success.size();
3864 }
3865
3866 public final Iterator<String> getSuccessIterator() {
3867 return success == null? null : success.iterator();
3868 }
3869
3870 public final void addToSuccess(final String elem) {
3871 if (success == null) {
3872 success = new ArrayList<String>();
3873 }
3874 success.add(elem);
3875 }
3876
3877 public final List<String> getSuccess() {
3878 return success;
3879 }
3880
3881 public final infoListQuery_result setSuccess(final List<String> success) {
3882 this.success = success;
3883 return this;
3884 }
3885
3886 public final void unsetSuccess() {
3887 success = null;
3888 }
3889
3890
3891
3892
3893
3894 public final boolean isSetSuccess() {
3895 return success != null;
3896 }
3897
3898 public final void setSuccessIsSet(final boolean value) {
3899 if (!value) {
3900 success = null;
3901 }
3902 }
3903
3904 @Override
3905 public final void setFieldValue(final _Fields field, final Object value) {
3906 if (field == _Fields.SUCCESS) {
3907 if (value == null) {
3908 unsetSuccess();
3909 } else {
3910 setSuccess((List<String>) value);
3911 }
3912 }
3913 }
3914
3915 @Override
3916 public final Object getFieldValue(final _Fields field) {
3917 if (field == _Fields.SUCCESS) {
3918 return getSuccess();
3919 }
3920 throw new IllegalStateException();
3921 }
3922
3923
3924
3925
3926
3927
3928 @Override
3929 public final boolean isSet(final _Fields field) {
3930 if (field == null) {
3931 throw new IllegalArgumentException();
3932 }
3933
3934 if (field == _Fields.SUCCESS) {
3935 return isSetSuccess();
3936 }
3937 throw new IllegalStateException();
3938 }
3939
3940 @Override
3941 public final boolean equals(final Object that) {
3942 if (that == null) {
3943 return false;
3944 }
3945 if (that instanceof infoListQuery_result) {
3946 return equals((infoListQuery_result) that);
3947 }
3948 return false;
3949 }
3950
3951 public final boolean equals(final infoListQuery_result that) {
3952 if (that == null) {
3953 return false;
3954 }
3955
3956 final boolean this_present_success = isSetSuccess();
3957 final boolean that_present_success = that.isSetSuccess();
3958 if (this_present_success || that_present_success) {
3959 if (!(this_present_success && that_present_success)) {
3960 return false;
3961 }
3962 return success.equals(that.success);
3963 }
3964
3965 return true;
3966 }
3967
3968 @Override
3969 public final int hashCode() {
3970 return 0;
3971 }
3972
3973 @Override
3974 public final int compareTo(final infoListQuery_result other) {
3975 if (!getClass().equals(other.getClass())) {
3976 return getClass().getName().compareTo(other.getClass().getName());
3977 }
3978
3979 int lastComparison;
3980
3981 lastComparison =
3982 Boolean.valueOf(isSetSuccess()).compareTo(other.isSetSuccess());
3983 if (lastComparison != 0) {
3984 return lastComparison;
3985 }
3986 if (isSetSuccess()) {
3987 lastComparison = TBaseHelper.compareTo(success, other.success);
3988 return lastComparison;
3989 }
3990 return 0;
3991 }
3992
3993 @Override
3994 public final _Fields fieldForId(final int fieldId) {
3995 return _Fields.findByThriftId(fieldId);
3996 }
3997
3998 @Override
3999 public final void read(final TProtocol iprot) throws TException {
4000 schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
4001 }
4002
4003 @Override
4004 public final void write(final TProtocol oprot) throws TException {
4005 schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
4006 }
4007
4008 @Override
4009 public final String toString() {
4010 final StringBuilder sb = new StringBuilder("infoListQuery_result(");
4011 sb.append("success:");
4012 if (success == null) {
4013 sb.append("null");
4014 } else {
4015 sb.append(success);
4016 }
4017 sb.append(')');
4018 return sb.toString();
4019 }
4020
4021 public final void validate() throws TException {
4022
4023
4024 }
4025
4026 private void writeObject(final ObjectOutputStream out) throws IOException {
4027 try {
4028 write(new TCompactProtocol(new TIOStreamTransport(out)));
4029 } catch (final TException te) {
4030 throw new IOException(te);
4031 }
4032 }
4033
4034 private void readObject(final ObjectInputStream in)
4035 throws IOException, ClassNotFoundException {
4036 try {
4037 read(new TCompactProtocol(new TIOStreamTransport(in)));
4038 } catch (final TException te) {
4039 throw new IOException(te);
4040 }
4041 }
4042
4043 private static class infoListQuery_resultStandardSchemeFactory
4044 implements SchemeFactory {
4045 @Override
4046 public final infoListQuery_resultStandardScheme getScheme() {
4047 return new infoListQuery_resultStandardScheme();
4048 }
4049 }
4050
4051 private static class infoListQuery_resultStandardScheme
4052 extends StandardScheme<infoListQuery_result> {
4053
4054 @Override
4055 public final void read(final TProtocol iprot,
4056 final infoListQuery_result struct)
4057 throws TException {
4058 TField schemeField;
4059 iprot.readStructBegin();
4060 while (true) {
4061 schemeField = iprot.readFieldBegin();
4062 if (schemeField.type == TType.STOP) {
4063 break;
4064 }
4065 if (schemeField.id == 0) {
4066 if (schemeField.type == TType.LIST) {
4067 {
4068 final TList list0 = iprot.readListBegin();
4069 struct.success = new ArrayList<String>(list0.size);
4070 for (int _i1 = 0; _i1 < list0.size; ++_i1) {
4071 final String elem2;
4072 elem2 = iprot.readString();
4073 struct.success.add(elem2);
4074 }
4075 iprot.readListEnd();
4076 }
4077 struct.setSuccessIsSet(true);
4078 } else {
4079 TProtocolUtil.skip(iprot, schemeField.type);
4080 }
4081 } else {
4082 TProtocolUtil.skip(iprot, schemeField.type);
4083 }
4084 iprot.readFieldEnd();
4085 }
4086 iprot.readStructEnd();
4087
4088
4089
4090 struct.validate();
4091 }
4092
4093 @Override
4094 public final void write(final TProtocol oprot,
4095 final infoListQuery_result struct)
4096 throws TException {
4097 struct.validate();
4098
4099 oprot.writeStructBegin(STRUCT_DESC);
4100 if (struct.success != null) {
4101 oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
4102 {
4103 oprot.writeListBegin(
4104 new TList(TType.STRING, struct.success.size()));
4105 for (final String _iter3 : struct.success) {
4106 oprot.writeString(_iter3);
4107 }
4108 oprot.writeListEnd();
4109 }
4110 oprot.writeFieldEnd();
4111 }
4112 oprot.writeFieldStop();
4113 oprot.writeStructEnd();
4114 }
4115
4116 }
4117
4118 private static class infoListQuery_resultTupleSchemeFactory
4119 implements SchemeFactory {
4120 @Override
4121 public final infoListQuery_resultTupleScheme getScheme() {
4122 return new infoListQuery_resultTupleScheme();
4123 }
4124 }
4125
4126 private static class infoListQuery_resultTupleScheme
4127 extends TupleScheme<infoListQuery_result> {
4128
4129 @Override
4130 public final void write(final TProtocol prot,
4131 final infoListQuery_result struct)
4132 throws TException {
4133 final TTupleProtocol oprot = (TTupleProtocol) prot;
4134 final BitSet optionals = new BitSet();
4135 if (struct.isSetSuccess()) {
4136 optionals.set(0);
4137 }
4138 oprot.writeBitSet(optionals, 1);
4139 if (struct.isSetSuccess()) {
4140 {
4141 oprot.writeI32(struct.success.size());
4142 for (final String _iter4 : struct.success) {
4143 oprot.writeString(_iter4);
4144 }
4145 }
4146 }
4147 }
4148
4149 @Override
4150 public final void read(final TProtocol prot,
4151 final infoListQuery_result struct)
4152 throws TException {
4153 final TTupleProtocol iprot = (TTupleProtocol) prot;
4154 final BitSet incoming = iprot.readBitSet(1);
4155 if (incoming.get(0)) {
4156 {
4157 final TList list = new TList(TType.STRING, iprot.readI32());
4158 struct.success = new ArrayList<String>(list.size);
4159 for (int _i6 = 0; _i6 < list.size; ++_i6) {
4160 final String elem7;
4161 elem7 = iprot.readString();
4162 struct.success.add(elem7);
4163 }
4164 }
4165 struct.setSuccessIsSet(true);
4166 }
4167 }
4168 }
4169
4170 }
4171
4172 }