View Javadoc
1   /*
2    * This file is part of Waarp Project (named also Waarp or GG).
3    *
4    *  Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
5    *  tags. See the COPYRIGHT.txt in the distribution for a full listing of
6    * individual contributors.
7    *
8    *  All Waarp Project is free software: you can redistribute it and/or
9    * modify it under the terms of the GNU General Public License as published by
10   * the Free Software Foundation, either version 3 of the License, or (at your
11   * option) any later version.
12   *
13   * Waarp is distributed in the hope that it will be useful, but WITHOUT ANY
14   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
15   * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16   *
17   *  You should have received a copy of the GNU General Public License along with
18   * Waarp . If not, see <http://www.gnu.org/licenses/>.
19   */
20  
21  /**
22   * Autogenerated by Thrift Compiler (0.9.0)
23   * <p>
24   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
25   */
26  package org.waarp.thrift.r66;
27  
28  import org.apache.thrift.EncodingUtils;
29  import org.apache.thrift.TBase;
30  import org.apache.thrift.TBaseHelper;
31  import org.apache.thrift.TException;
32  import org.apache.thrift.TFieldIdEnum;
33  import org.apache.thrift.TFieldRequirementType;
34  import org.apache.thrift.meta_data.EnumMetaData;
35  import org.apache.thrift.meta_data.FieldMetaData;
36  import org.apache.thrift.meta_data.FieldValueMetaData;
37  import org.apache.thrift.protocol.TCompactProtocol;
38  import org.apache.thrift.protocol.TField;
39  import org.apache.thrift.protocol.TProtocol;
40  import org.apache.thrift.protocol.TProtocolException;
41  import org.apache.thrift.protocol.TProtocolUtil;
42  import org.apache.thrift.protocol.TStruct;
43  import org.apache.thrift.protocol.TTupleProtocol;
44  import org.apache.thrift.protocol.TType;
45  import org.apache.thrift.scheme.IScheme;
46  import org.apache.thrift.scheme.SchemeFactory;
47  import org.apache.thrift.scheme.StandardScheme;
48  import org.apache.thrift.scheme.TupleScheme;
49  import org.apache.thrift.transport.TIOStreamTransport;
50  
51  import java.io.IOException;
52  import java.io.ObjectInputStream;
53  import java.io.ObjectOutputStream;
54  import java.util.BitSet;
55  import java.util.Collections;
56  import java.util.EnumMap;
57  import java.util.EnumSet;
58  import java.util.HashMap;
59  import java.util.Map;
60  
61  public class R66Result
62      implements TBase<R66Result, R66Result._Fields>, Cloneable {
63    private static final String START2 = "start";
64  
65    private static final String MODETRANSFER2 = "modetransfer";
66  
67    private static final String BLOCKSIZE2 = "blocksize";
68  
69    private static final String ORIGINALFILENAME2 = "originalfilename";
70  
71    private static final String ISMOVED2 = "ismoved";
72  
73    private static final String RETRIEVEMODE2 = "retrievemode";
74  
75    private static final String GLOBALLASTSTEP2 = "globallaststep";
76  
77    private static final String GLOBALSTEP2 = "globalstep";
78  
79    private static final String RESULTINFO2 = "resultinfo";
80  
81    private static final String ACTION2 = "action";
82  
83    private static final String DESTUID2 = "destuid";
84  
85    private static final String FROMUID2 = "fromuid";
86  
87    /**
88     *
89     */
90    private static final long serialVersionUID = 2232890139671363595L;
91  
92    private static final TStruct STRUCT_DESC = new TStruct("R66Result");
93  
94    private static final TField MODE_FIELD_DESC =
95        new TField("mode", TType.I32, (short) 1);
96    private static final TField FROMUID_FIELD_DESC =
97        new TField(FROMUID2, TType.STRING, (short) 2);
98    private static final TField DESTUID_FIELD_DESC =
99        new TField(DESTUID2, TType.STRING, (short) 3);
100   private static final TField FILE_FIELD_DESC =
101       new TField("file", TType.STRING, (short) 4);
102   private static final TField RULE_FIELD_DESC =
103       new TField("rule", TType.STRING, (short) 5);
104   private static final TField TID_FIELD_DESC =
105       new TField("tid", TType.I64, (short) 20);
106   private static final TField ACTION_FIELD_DESC =
107       new TField(ACTION2, TType.I32, (short) 21);
108   private static final TField CODE_FIELD_DESC =
109       new TField("code", TType.I32, (short) 30);
110   private static final TField RESULTINFO_FIELD_DESC =
111       new TField(RESULTINFO2, TType.STRING, (short) 31);
112   private static final TField GLOBALSTEP_FIELD_DESC =
113       new TField(GLOBALSTEP2, TType.I32, (short) 32);
114   private static final TField GLOBALLASTSTEP_FIELD_DESC =
115       new TField(GLOBALLASTSTEP2, TType.I32, (short) 33);
116   private static final TField STEP_FIELD_DESC =
117       new TField("step", TType.I32, (short) 34);
118   private static final TField RANK_FIELD_DESC =
119       new TField("rank", TType.I32, (short) 35);
120   private static final TField RETRIEVEMODE_FIELD_DESC =
121       new TField(RETRIEVEMODE2, TType.BOOL, (short) 36);
122   private static final TField ISMOVED_FIELD_DESC =
123       new TField(ISMOVED2, TType.BOOL, (short) 37);
124   private static final TField ORIGINALFILENAME_FIELD_DESC =
125       new TField(ORIGINALFILENAME2, TType.STRING, (short) 38);
126   private static final TField BLOCKSIZE_FIELD_DESC =
127       new TField(BLOCKSIZE2, TType.I32, (short) 39);
128   private static final TField MODETRANSFER_FIELD_DESC =
129       new TField(MODETRANSFER2, TType.I32, (short) 40);
130   private static final TField START_FIELD_DESC =
131       new TField(START2, TType.STRING, (short) 41);
132   private static final TField STOP_FIELD_DESC =
133       new TField("stop", TType.STRING, (short) 42);
134 
135   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
136       new HashMap<Class<? extends IScheme>, SchemeFactory>();
137 
138   static {
139     schemes.put(StandardScheme.class, new R66ResultStandardSchemeFactory());
140     schemes.put(TupleScheme.class, new R66ResultTupleSchemeFactory());
141   }
142 
143   private RequestMode mode; // required
144   private String fromuid; // optional
145   private String destuid; // optional
146   private String file; // optional
147   private String rule; // optional
148   private long tid; // optional
149   private Action action; // optional
150   private ErrorCode code; // required
151   private String resultinfo; // required
152   private int globalstep; // optional
153   private int globallaststep; // optional
154   private int step; // optional
155   private int rank; // optional
156   private boolean retrievemode; // optional
157   private boolean ismoved; // optional
158   private String originalfilename; // optional
159   private int blocksize; // optional
160   private int modetransfer; // optional
161   private String start; // optional
162   private String stop; // optional
163 
164   @Override
165   public final R66Result clone() throws CloneNotSupportedException {
166     return (R66Result) super.clone();
167   }
168 
169   /**
170    * The set of fields this struct contains, along with convenience methods
171    * for
172    * finding and manipulating them.
173    */
174   public enum _Fields implements TFieldIdEnum {
175     /**
176      * @see RequestMode
177      */
178     MODE((short) 1, "mode"), FROMUID((short) 2, FROMUID2),
179     DESTUID((short) 3, DESTUID2), FILE((short) 4, "file"),
180     RULE((short) 5, "rule"), TID((short) 20, "tid"),
181     /**
182      * @see Action
183      */
184     ACTION((short) 21, ACTION2),
185     /**
186      * @see ErrorCode
187      */
188     CODE((short) 30, "code"), RESULTINFO((short) 31, RESULTINFO2),
189     GLOBALSTEP((short) 32, GLOBALSTEP2),
190     GLOBALLASTSTEP((short) 33, GLOBALLASTSTEP2), STEP((short) 34, "step"),
191     RANK((short) 35, "rank"), RETRIEVEMODE((short) 36, RETRIEVEMODE2),
192     ISMOVED((short) 37, ISMOVED2),
193     ORIGINALFILENAME((short) 38, ORIGINALFILENAME2),
194     BLOCKSIZE((short) 39, BLOCKSIZE2), MODETRANSFER((short) 40, MODETRANSFER2),
195     START((short) 41, START2), STOP((short) 42, "stop");
196 
197     private static final Map<String, _Fields> byName =
198         new HashMap<String, _Fields>();
199 
200     static {
201       for (final _Fields field : EnumSet.allOf(_Fields.class)) {
202         byName.put(field.getFieldName(), field);
203       }
204     }
205 
206     /**
207      * Find the _Fields constant that matches fieldId, or null if its not
208      * found.
209      */
210     public static _Fields findByThriftId(final int fieldId) {
211       switch (fieldId) {
212         case 1: // MODE
213           return MODE;
214         case 2: // FROMUID
215           return FROMUID;
216         case 3: // DESTUID
217           return DESTUID;
218         case 4: // FILE
219           return FILE;
220         case 5: // RULE
221           return RULE;
222         case 20: // TID
223           return TID;
224         case 21: // ACTION
225           return ACTION;
226         case 30: // CODE
227           return CODE;
228         case 31: // RESULTINFO
229           return RESULTINFO;
230         case 32: // GLOBALSTEP
231           return GLOBALSTEP;
232         case 33: // GLOBALLASTSTEP
233           return GLOBALLASTSTEP;
234         case 34: // STEP
235           return STEP;
236         case 35: // RANK
237           return RANK;
238         case 36: // RETRIEVEMODE
239           return RETRIEVEMODE;
240         case 37: // ISMOVED
241           return ISMOVED;
242         case 38: // ORIGINALFILENAME
243           return ORIGINALFILENAME;
244         case 39: // BLOCKSIZE
245           return BLOCKSIZE;
246         case 40: // MODETRANSFER
247           return MODETRANSFER;
248         case 41: // START
249           return START;
250         case 42: // STOP
251           return STOP;
252         default:
253           return null;
254       }
255     }
256 
257     /**
258      * Find the _Fields constant that matches fieldId, throwing an exception
259      * if
260      * it is not found.
261      */
262     public static _Fields findByThriftIdOrThrow(final int fieldId) {
263       final _Fields fields = findByThriftId(fieldId);
264       if (fields == null) {
265         throw new IllegalArgumentException(
266             "Field " + fieldId + " doesn't exist!");
267       }
268       return fields;
269     }
270 
271     /**
272      * Find the _Fields constant that matches name, or null if its not
273      * found.
274      */
275     public static _Fields findByName(final String name) {
276       return byName.get(name);
277     }
278 
279     private final short thriftId;
280     private final String fieldName;
281 
282     _Fields(final short thriftId, final String fieldName) {
283       this.thriftId = thriftId;
284       this.fieldName = fieldName;
285     }
286 
287     @Override
288     public final short getThriftFieldId() {
289       return thriftId;
290     }
291 
292     @Override
293     public final String getFieldName() {
294       return fieldName;
295     }
296   }
297 
298   // isset id assignments
299   private static final int TID_ISSET_ID = 0;
300   private static final int GLOBALSTEP_ISSET_ID = 1;
301   private static final int GLOBALLASTSTEP_ISSET_ID = 2;
302   private static final int STEP_ISSET_ID = 3;
303   private static final int RANK_ISSET_ID = 4;
304   private static final int RETRIEVEMODE_ISSET_ID = 5;
305   private static final int ISMOVED_ISSET_ID = 6;
306   private static final int BLOCKSIZE_ISSET_ID = 7;
307   private static final int MODETRANSFER_ISSET_ID = 8;
308   private short issetBitfield;
309   public static final Map<_Fields, FieldMetaData> metaDataMap;
310 
311   static {
312     final Map<_Fields, FieldMetaData> tmpMap =
313         new EnumMap<_Fields, FieldMetaData>(_Fields.class);
314     tmpMap.put(_Fields.MODE,
315                new FieldMetaData("mode", TFieldRequirementType.REQUIRED,
316                                  new EnumMetaData(TType.ENUM,
317                                                   RequestMode.class)));
318     tmpMap.put(_Fields.FROMUID,
319                new FieldMetaData(FROMUID2, TFieldRequirementType.OPTIONAL,
320                                  new FieldValueMetaData(TType.STRING)));
321     tmpMap.put(_Fields.DESTUID,
322                new FieldMetaData(DESTUID2, TFieldRequirementType.OPTIONAL,
323                                  new FieldValueMetaData(TType.STRING)));
324     tmpMap.put(_Fields.FILE,
325                new FieldMetaData("file", TFieldRequirementType.OPTIONAL,
326                                  new FieldValueMetaData(TType.STRING)));
327     tmpMap.put(_Fields.RULE,
328                new FieldMetaData("rule", TFieldRequirementType.OPTIONAL,
329                                  new FieldValueMetaData(TType.STRING)));
330     tmpMap.put(_Fields.TID,
331                new FieldMetaData("tid", TFieldRequirementType.OPTIONAL,
332                                  new FieldValueMetaData(TType.I64)));
333     tmpMap.put(_Fields.ACTION,
334                new FieldMetaData(ACTION2, TFieldRequirementType.OPTIONAL,
335                                  new EnumMetaData(TType.ENUM, Action.class)));
336     tmpMap.put(_Fields.CODE,
337                new FieldMetaData("code", TFieldRequirementType.REQUIRED,
338                                  new EnumMetaData(TType.ENUM,
339                                                   ErrorCode.class)));
340     tmpMap.put(_Fields.RESULTINFO,
341                new FieldMetaData(RESULTINFO2, TFieldRequirementType.REQUIRED,
342                                  new FieldValueMetaData(TType.STRING)));
343     tmpMap.put(_Fields.GLOBALSTEP,
344                new FieldMetaData(GLOBALSTEP2, TFieldRequirementType.OPTIONAL,
345                                  new FieldValueMetaData(TType.I32)));
346     tmpMap.put(_Fields.GLOBALLASTSTEP, new FieldMetaData(GLOBALLASTSTEP2,
347                                                          TFieldRequirementType.OPTIONAL,
348                                                          new FieldValueMetaData(
349                                                              TType.I32)));
350     tmpMap.put(_Fields.STEP,
351                new FieldMetaData("step", TFieldRequirementType.OPTIONAL,
352                                  new FieldValueMetaData(TType.I32)));
353     tmpMap.put(_Fields.RANK,
354                new FieldMetaData("rank", TFieldRequirementType.OPTIONAL,
355                                  new FieldValueMetaData(TType.I32)));
356     tmpMap.put(_Fields.RETRIEVEMODE,
357                new FieldMetaData(RETRIEVEMODE2, TFieldRequirementType.OPTIONAL,
358                                  new FieldValueMetaData(TType.BOOL)));
359     tmpMap.put(_Fields.ISMOVED,
360                new FieldMetaData(ISMOVED2, TFieldRequirementType.OPTIONAL,
361                                  new FieldValueMetaData(TType.BOOL)));
362     tmpMap.put(_Fields.ORIGINALFILENAME, new FieldMetaData(ORIGINALFILENAME2,
363                                                            TFieldRequirementType.OPTIONAL,
364                                                            new FieldValueMetaData(
365                                                                TType.STRING)));
366     tmpMap.put(_Fields.BLOCKSIZE,
367                new FieldMetaData(BLOCKSIZE2, TFieldRequirementType.OPTIONAL,
368                                  new FieldValueMetaData(TType.I32)));
369     tmpMap.put(_Fields.MODETRANSFER,
370                new FieldMetaData(MODETRANSFER2, TFieldRequirementType.OPTIONAL,
371                                  new FieldValueMetaData(TType.I32)));
372     tmpMap.put(_Fields.START,
373                new FieldMetaData(START2, TFieldRequirementType.OPTIONAL,
374                                  new FieldValueMetaData(TType.STRING)));
375     tmpMap.put(_Fields.STOP,
376                new FieldMetaData("stop", TFieldRequirementType.OPTIONAL,
377                                  new FieldValueMetaData(TType.STRING)));
378     metaDataMap = Collections.unmodifiableMap(tmpMap);
379     FieldMetaData.addStructMetaDataMap(R66Result.class, metaDataMap);
380   }
381 
382   public R66Result() {
383   }
384 
385   public R66Result(final RequestMode mode, final ErrorCode code,
386                    final String resultinfo) {
387     this();
388     this.mode = mode;
389     this.code = code;
390     this.resultinfo = resultinfo;
391   }
392 
393   /**
394    * Performs a deep copy on <i>other</i>.
395    */
396   public R66Result(final R66Result other) {
397     issetBitfield = other.issetBitfield;
398     if (other.isSetMode()) {
399       mode = other.mode;
400     }
401     if (other.isSetFromuid()) {
402       fromuid = other.fromuid;
403     }
404     if (other.isSetDestuid()) {
405       destuid = other.destuid;
406     }
407     if (other.isSetFile()) {
408       file = other.file;
409     }
410     if (other.isSetRule()) {
411       rule = other.rule;
412     }
413     tid = other.tid;
414     if (other.isSetAction()) {
415       action = other.action;
416     }
417     if (other.isSetCode()) {
418       code = other.code;
419     }
420     if (other.isSetResultinfo()) {
421       resultinfo = other.resultinfo;
422     }
423     globalstep = other.globalstep;
424     globallaststep = other.globallaststep;
425     step = other.step;
426     rank = other.rank;
427     retrievemode = other.retrievemode;
428     ismoved = other.ismoved;
429     if (other.isSetOriginalfilename()) {
430       originalfilename = other.originalfilename;
431     }
432     blocksize = other.blocksize;
433     modetransfer = other.modetransfer;
434     if (other.isSetStart()) {
435       start = other.start;
436     }
437     if (other.isSetStop()) {
438       stop = other.stop;
439     }
440   }
441 
442   @Override
443   public final R66Result deepCopy() {
444     return new R66Result(this);
445   }
446 
447   @Override
448   public final void clear() {
449     mode = null;
450     fromuid = null;
451     destuid = null;
452     file = null;
453     rule = null;
454     setTidIsSet(false);
455     tid = 0;
456     action = null;
457     code = null;
458     resultinfo = null;
459     setGlobalstepIsSet(false);
460     globalstep = 0;
461     setGloballaststepIsSet(false);
462     globallaststep = 0;
463     setStepIsSet(false);
464     step = 0;
465     setRankIsSet(false);
466     rank = 0;
467     setRetrievemodeIsSet(false);
468     retrievemode = false;
469     setIsmovedIsSet(false);
470     ismoved = false;
471     originalfilename = null;
472     setBlocksizeIsSet(false);
473     blocksize = 0;
474     setModetransferIsSet(false);
475     modetransfer = 0;
476     start = null;
477     stop = null;
478   }
479 
480   /**
481    * @see RequestMode
482    */
483   public final RequestMode getMode() {
484     return mode;
485   }
486 
487   /**
488    * @see RequestMode
489    */
490   public final R66Result setMode(final RequestMode mode) {
491     this.mode = mode;
492     return this;
493   }
494 
495   public final void unsetMode() {
496     mode = null;
497   }
498 
499   /**
500    * Returns true if field mode is set (has been assigned a value) and false
501    * otherwise
502    */
503   public final boolean isSetMode() {
504     return mode != null;
505   }
506 
507   public final void setModeIsSet(final boolean value) {
508     if (!value) {
509       mode = null;
510     }
511   }
512 
513   public final String getFromuid() {
514     return fromuid;
515   }
516 
517   public final R66Result setFromuid(final String fromuid) {
518     this.fromuid = fromuid;
519     return this;
520   }
521 
522   public final void unsetFromuid() {
523     fromuid = null;
524   }
525 
526   /**
527    * Returns true if field fromuid is set (has been assigned a value) and
528    * false
529    * otherwise
530    */
531   public final boolean isSetFromuid() {
532     return fromuid != null;
533   }
534 
535   public final void setFromuidIsSet(final boolean value) {
536     if (!value) {
537       fromuid = null;
538     }
539   }
540 
541   public final String getDestuid() {
542     return destuid;
543   }
544 
545   public final R66Result setDestuid(final String destuid) {
546     this.destuid = destuid;
547     return this;
548   }
549 
550   public final void unsetDestuid() {
551     destuid = null;
552   }
553 
554   /**
555    * Returns true if field destuid is set (has been assigned a value) and
556    * false
557    * otherwise
558    */
559   public final boolean isSetDestuid() {
560     return destuid != null;
561   }
562 
563   public final void setDestuidIsSet(final boolean value) {
564     if (!value) {
565       destuid = null;
566     }
567   }
568 
569   public final String getFile() {
570     return file;
571   }
572 
573   public final R66Result setFile(final String file) {
574     this.file = file;
575     return this;
576   }
577 
578   public final void unsetFile() {
579     file = null;
580   }
581 
582   /**
583    * Returns true if field file is set (has been assigned a value) and false
584    * otherwise
585    */
586   public final boolean isSetFile() {
587     return file != null;
588   }
589 
590   public final void setFileIsSet(final boolean value) {
591     if (!value) {
592       file = null;
593     }
594   }
595 
596   public final String getRule() {
597     return rule;
598   }
599 
600   public final R66Result setRule(final String rule) {
601     this.rule = rule;
602     return this;
603   }
604 
605   public final void unsetRule() {
606     rule = null;
607   }
608 
609   /**
610    * Returns true if field rule is set (has been assigned a value) and false
611    * otherwise
612    */
613   public final boolean isSetRule() {
614     return rule != null;
615   }
616 
617   public final void setRuleIsSet(final boolean value) {
618     if (!value) {
619       rule = null;
620     }
621   }
622 
623   public final long getTid() {
624     return tid;
625   }
626 
627   public final R66Result setTid(final long tid) {
628     this.tid = tid;
629     setTidIsSet(true);
630     return this;
631   }
632 
633   public final void unsetTid() {
634     issetBitfield = EncodingUtils.clearBit(issetBitfield, TID_ISSET_ID);
635   }
636 
637   /**
638    * Returns true if field tid is set (has been assigned a value) and false
639    * otherwise
640    */
641   public final boolean isSetTid() {
642     return EncodingUtils.testBit(issetBitfield, TID_ISSET_ID);
643   }
644 
645   public final void setTidIsSet(final boolean value) {
646     issetBitfield = EncodingUtils.setBit(issetBitfield, TID_ISSET_ID, value);
647   }
648 
649   /**
650    * @see Action
651    */
652   public final Action getAction() {
653     return action;
654   }
655 
656   /**
657    * @see Action
658    */
659   public final R66Result setAction(final Action action) {
660     this.action = action;
661     return this;
662   }
663 
664   public final void unsetAction() {
665     action = null;
666   }
667 
668   /**
669    * Returns true if field action is set (has been assigned a value) and false
670    * otherwise
671    */
672   public final boolean isSetAction() {
673     return action != null;
674   }
675 
676   public final void setActionIsSet(final boolean value) {
677     if (!value) {
678       action = null;
679     }
680   }
681 
682   /**
683    * @see ErrorCode
684    */
685   public final ErrorCode getCode() {
686     return code;
687   }
688 
689   /**
690    * @see ErrorCode
691    */
692   public final R66Result setCode(final ErrorCode code) {
693     this.code = code;
694     return this;
695   }
696 
697   public final void unsetCode() {
698     code = null;
699   }
700 
701   /**
702    * Returns true if field code is set (has been assigned a value) and false
703    * otherwise
704    */
705   public final boolean isSetCode() {
706     return code != null;
707   }
708 
709   public final void setCodeIsSet(final boolean value) {
710     if (!value) {
711       code = null;
712     }
713   }
714 
715   public final String getResultinfo() {
716     return resultinfo;
717   }
718 
719   public final R66Result setResultinfo(final String resultinfo) {
720     this.resultinfo = resultinfo;
721     return this;
722   }
723 
724   public final void unsetResultinfo() {
725     resultinfo = null;
726   }
727 
728   /**
729    * Returns true if field resultinfo is set (has been assigned a value) and
730    * false otherwise
731    */
732   public final boolean isSetResultinfo() {
733     return resultinfo != null;
734   }
735 
736   public final void setResultinfoIsSet(final boolean value) {
737     if (!value) {
738       resultinfo = null;
739     }
740   }
741 
742   public final int getGlobalstep() {
743     return globalstep;
744   }
745 
746   public final R66Result setGlobalstep(final int globalstep) {
747     this.globalstep = globalstep;
748     setGlobalstepIsSet(true);
749     return this;
750   }
751 
752   public final void unsetGlobalstep() {
753     issetBitfield = EncodingUtils.clearBit(issetBitfield, GLOBALSTEP_ISSET_ID);
754   }
755 
756   /**
757    * Returns true if field globalstep is set (has been assigned a value) and
758    * false otherwise
759    */
760   public final boolean isSetGlobalstep() {
761     return EncodingUtils.testBit(issetBitfield, GLOBALSTEP_ISSET_ID);
762   }
763 
764   public final void setGlobalstepIsSet(final boolean value) {
765     issetBitfield =
766         EncodingUtils.setBit(issetBitfield, GLOBALSTEP_ISSET_ID, value);
767   }
768 
769   public final int getGloballaststep() {
770     return globallaststep;
771   }
772 
773   public final R66Result setGloballaststep(final int globallaststep) {
774     this.globallaststep = globallaststep;
775     setGloballaststepIsSet(true);
776     return this;
777   }
778 
779   public final void unsetGloballaststep() {
780     issetBitfield =
781         EncodingUtils.clearBit(issetBitfield, GLOBALLASTSTEP_ISSET_ID);
782   }
783 
784   /**
785    * Returns true if field globallaststep is set (has been assigned a value)
786    * and
787    * false otherwise
788    */
789   public final boolean isSetGloballaststep() {
790     return EncodingUtils.testBit(issetBitfield, GLOBALLASTSTEP_ISSET_ID);
791   }
792 
793   public final void setGloballaststepIsSet(final boolean value) {
794     issetBitfield =
795         EncodingUtils.setBit(issetBitfield, GLOBALLASTSTEP_ISSET_ID, value);
796   }
797 
798   public final int getStep() {
799     return step;
800   }
801 
802   public final R66Result setStep(final int step) {
803     this.step = step;
804     setStepIsSet(true);
805     return this;
806   }
807 
808   public final void unsetStep() {
809     issetBitfield = EncodingUtils.clearBit(issetBitfield, STEP_ISSET_ID);
810   }
811 
812   /**
813    * Returns true if field step is set (has been assigned a value) and false
814    * otherwise
815    */
816   public final boolean isSetStep() {
817     return EncodingUtils.testBit(issetBitfield, STEP_ISSET_ID);
818   }
819 
820   public final void setStepIsSet(final boolean value) {
821     issetBitfield = EncodingUtils.setBit(issetBitfield, STEP_ISSET_ID, value);
822   }
823 
824   public final int getRank() {
825     return rank;
826   }
827 
828   public final R66Result setRank(final int rank) {
829     this.rank = rank;
830     setRankIsSet(true);
831     return this;
832   }
833 
834   public final void unsetRank() {
835     issetBitfield = EncodingUtils.clearBit(issetBitfield, RANK_ISSET_ID);
836   }
837 
838   /**
839    * Returns true if field rank is set (has been assigned a value) and false
840    * otherwise
841    */
842   public final boolean isSetRank() {
843     return EncodingUtils.testBit(issetBitfield, RANK_ISSET_ID);
844   }
845 
846   public final void setRankIsSet(final boolean value) {
847     issetBitfield = EncodingUtils.setBit(issetBitfield, RANK_ISSET_ID, value);
848   }
849 
850   public final boolean isRetrievemode() {
851     return retrievemode;
852   }
853 
854   public final R66Result setRetrievemode(final boolean retrievemode) {
855     this.retrievemode = retrievemode;
856     setRetrievemodeIsSet(true);
857     return this;
858   }
859 
860   public final void unsetRetrievemode() {
861     issetBitfield =
862         EncodingUtils.clearBit(issetBitfield, RETRIEVEMODE_ISSET_ID);
863   }
864 
865   /**
866    * Returns true if field retrievemode is set (has been assigned a value) and
867    * false otherwise
868    */
869   public final boolean isSetRetrievemode() {
870     return EncodingUtils.testBit(issetBitfield, RETRIEVEMODE_ISSET_ID);
871   }
872 
873   public final void setRetrievemodeIsSet(final boolean value) {
874     issetBitfield =
875         EncodingUtils.setBit(issetBitfield, RETRIEVEMODE_ISSET_ID, value);
876   }
877 
878   public final boolean isIsmoved() {
879     return ismoved;
880   }
881 
882   public final R66Result setIsmoved(final boolean ismoved) {
883     this.ismoved = ismoved;
884     setIsmovedIsSet(true);
885     return this;
886   }
887 
888   public final void unsetIsmoved() {
889     issetBitfield = EncodingUtils.clearBit(issetBitfield, ISMOVED_ISSET_ID);
890   }
891 
892   /**
893    * Returns true if field ismoved is set (has been assigned a value) and
894    * false
895    * otherwise
896    */
897   public final boolean isSetIsmoved() {
898     return EncodingUtils.testBit(issetBitfield, ISMOVED_ISSET_ID);
899   }
900 
901   public final void setIsmovedIsSet(final boolean value) {
902     issetBitfield =
903         EncodingUtils.setBit(issetBitfield, ISMOVED_ISSET_ID, value);
904   }
905 
906   public final String getOriginalfilename() {
907     return originalfilename;
908   }
909 
910   public final R66Result setOriginalfilename(final String originalfilename) {
911     this.originalfilename = originalfilename;
912     return this;
913   }
914 
915   public final void unsetOriginalfilename() {
916     originalfilename = null;
917   }
918 
919   /**
920    * Returns true if field originalfilename is set (has been assigned a value)
921    * and false otherwise
922    */
923   public final boolean isSetOriginalfilename() {
924     return originalfilename != null;
925   }
926 
927   public final void setOriginalfilenameIsSet(final boolean value) {
928     if (!value) {
929       originalfilename = null;
930     }
931   }
932 
933   public final int getBlocksize() {
934     return blocksize;
935   }
936 
937   public final R66Result setBlocksize(final int blocksize) {
938     this.blocksize = blocksize;
939     setBlocksizeIsSet(true);
940     return this;
941   }
942 
943   public final void unsetBlocksize() {
944     issetBitfield = EncodingUtils.clearBit(issetBitfield, BLOCKSIZE_ISSET_ID);
945   }
946 
947   /**
948    * Returns true if field blocksize is set (has been assigned a value) and
949    * false otherwise
950    */
951   public final boolean isSetBlocksize() {
952     return EncodingUtils.testBit(issetBitfield, BLOCKSIZE_ISSET_ID);
953   }
954 
955   public final void setBlocksizeIsSet(final boolean value) {
956     issetBitfield =
957         EncodingUtils.setBit(issetBitfield, BLOCKSIZE_ISSET_ID, value);
958   }
959 
960   public final int getModetransfer() {
961     return modetransfer;
962   }
963 
964   public final R66Result setModetransfer(final int modetransfer) {
965     this.modetransfer = modetransfer;
966     setModetransferIsSet(true);
967     return this;
968   }
969 
970   public final void unsetModetransfer() {
971     issetBitfield =
972         EncodingUtils.clearBit(issetBitfield, MODETRANSFER_ISSET_ID);
973   }
974 
975   /**
976    * Returns true if field modetransfer is set (has been assigned a value) and
977    * false otherwise
978    */
979   public final boolean isSetModetransfer() {
980     return EncodingUtils.testBit(issetBitfield, MODETRANSFER_ISSET_ID);
981   }
982 
983   public final void setModetransferIsSet(final boolean value) {
984     issetBitfield =
985         EncodingUtils.setBit(issetBitfield, MODETRANSFER_ISSET_ID, value);
986   }
987 
988   public final String getStart() {
989     return start;
990   }
991 
992   public final R66Result setStart(final String start) {
993     this.start = start;
994     return this;
995   }
996 
997   public final void unsetStart() {
998     start = null;
999   }
1000 
1001   /**
1002    * Returns true if field start is set (has been assigned a value) and false
1003    * otherwise
1004    */
1005   public final boolean isSetStart() {
1006     return start != null;
1007   }
1008 
1009   public final void setStartIsSet(final boolean value) {
1010     if (!value) {
1011       start = null;
1012     }
1013   }
1014 
1015   public final String getStop() {
1016     return stop;
1017   }
1018 
1019   public final R66Result setStop(final String stop) {
1020     this.stop = stop;
1021     return this;
1022   }
1023 
1024   public final void unsetStop() {
1025     stop = null;
1026   }
1027 
1028   /**
1029    * Returns true if field stop is set (has been assigned a value) and false
1030    * otherwise
1031    */
1032   public final boolean isSetStop() {
1033     return stop != null;
1034   }
1035 
1036   public final void setStopIsSet(final boolean value) {
1037     if (!value) {
1038       stop = null;
1039     }
1040   }
1041 
1042   @Override
1043   public final void setFieldValue(final _Fields field, final Object value) {
1044     switch (field) {
1045       case MODE:
1046         if (value == null) {
1047           unsetMode();
1048         } else {
1049           setMode((RequestMode) value);
1050         }
1051         break;
1052 
1053       case FROMUID:
1054         if (value == null) {
1055           unsetFromuid();
1056         } else {
1057           setFromuid((String) value);
1058         }
1059         break;
1060 
1061       case DESTUID:
1062         if (value == null) {
1063           unsetDestuid();
1064         } else {
1065           setDestuid((String) value);
1066         }
1067         break;
1068 
1069       case FILE:
1070         if (value == null) {
1071           unsetFile();
1072         } else {
1073           setFile((String) value);
1074         }
1075         break;
1076 
1077       case RULE:
1078         if (value == null) {
1079           unsetRule();
1080         } else {
1081           setRule((String) value);
1082         }
1083         break;
1084 
1085       case TID:
1086         if (value == null) {
1087           unsetTid();
1088         } else {
1089           setTid((Long) value);
1090         }
1091         break;
1092 
1093       case ACTION:
1094         if (value == null) {
1095           unsetAction();
1096         } else {
1097           setAction((Action) value);
1098         }
1099         break;
1100 
1101       case CODE:
1102         if (value == null) {
1103           unsetCode();
1104         } else {
1105           setCode((ErrorCode) value);
1106         }
1107         break;
1108 
1109       case RESULTINFO:
1110         if (value == null) {
1111           unsetResultinfo();
1112         } else {
1113           setResultinfo((String) value);
1114         }
1115         break;
1116 
1117       case GLOBALSTEP:
1118         if (value == null) {
1119           unsetGlobalstep();
1120         } else {
1121           setGlobalstep((Integer) value);
1122         }
1123         break;
1124 
1125       case GLOBALLASTSTEP:
1126         if (value == null) {
1127           unsetGloballaststep();
1128         } else {
1129           setGloballaststep((Integer) value);
1130         }
1131         break;
1132 
1133       case STEP:
1134         if (value == null) {
1135           unsetStep();
1136         } else {
1137           setStep((Integer) value);
1138         }
1139         break;
1140 
1141       case RANK:
1142         if (value == null) {
1143           unsetRank();
1144         } else {
1145           setRank((Integer) value);
1146         }
1147         break;
1148 
1149       case RETRIEVEMODE:
1150         if (value == null) {
1151           unsetRetrievemode();
1152         } else {
1153           setRetrievemode((Boolean) value);
1154         }
1155         break;
1156 
1157       case ISMOVED:
1158         if (value == null) {
1159           unsetIsmoved();
1160         } else {
1161           setIsmoved((Boolean) value);
1162         }
1163         break;
1164 
1165       case ORIGINALFILENAME:
1166         if (value == null) {
1167           unsetOriginalfilename();
1168         } else {
1169           setOriginalfilename((String) value);
1170         }
1171         break;
1172 
1173       case BLOCKSIZE:
1174         if (value == null) {
1175           unsetBlocksize();
1176         } else {
1177           setBlocksize((Integer) value);
1178         }
1179         break;
1180 
1181       case MODETRANSFER:
1182         if (value == null) {
1183           unsetModetransfer();
1184         } else {
1185           setModetransfer((Integer) value);
1186         }
1187         break;
1188 
1189       case START:
1190         if (value == null) {
1191           unsetStart();
1192         } else {
1193           setStart((String) value);
1194         }
1195         break;
1196 
1197       case STOP:
1198         if (value == null) {
1199           unsetStop();
1200         } else {
1201           setStop((String) value);
1202         }
1203         break;
1204 
1205     }
1206   }
1207 
1208   @Override
1209   public final Object getFieldValue(final _Fields field) {
1210     switch (field) {
1211       case MODE:
1212         return getMode();
1213 
1214       case FROMUID:
1215         return getFromuid();
1216 
1217       case DESTUID:
1218         return getDestuid();
1219 
1220       case FILE:
1221         return getFile();
1222 
1223       case RULE:
1224         return getRule();
1225 
1226       case TID:
1227         return Long.valueOf(getTid());
1228 
1229       case ACTION:
1230         return getAction();
1231 
1232       case CODE:
1233         return getCode();
1234 
1235       case RESULTINFO:
1236         return getResultinfo();
1237 
1238       case GLOBALSTEP:
1239         return Integer.valueOf(getGlobalstep());
1240 
1241       case GLOBALLASTSTEP:
1242         return Integer.valueOf(getGloballaststep());
1243 
1244       case STEP:
1245         return Integer.valueOf(getStep());
1246 
1247       case RANK:
1248         return Integer.valueOf(getRank());
1249 
1250       case RETRIEVEMODE:
1251         return Boolean.valueOf(isRetrievemode());
1252 
1253       case ISMOVED:
1254         return Boolean.valueOf(isIsmoved());
1255 
1256       case ORIGINALFILENAME:
1257         return getOriginalfilename();
1258 
1259       case BLOCKSIZE:
1260         return Integer.valueOf(getBlocksize());
1261 
1262       case MODETRANSFER:
1263         return Integer.valueOf(getModetransfer());
1264 
1265       case START:
1266         return getStart();
1267 
1268       case STOP:
1269         return getStop();
1270 
1271     }
1272     throw new IllegalStateException();
1273   }
1274 
1275   /**
1276    * Returns true if field corresponding to fieldID is set (has been assigned
1277    * a
1278    * value) and false otherwise
1279    */
1280   @Override
1281   public final boolean isSet(final _Fields field) {
1282     if (field == null) {
1283       throw new IllegalArgumentException();
1284     }
1285 
1286     switch (field) {
1287       case MODE:
1288         return isSetMode();
1289       case FROMUID:
1290         return isSetFromuid();
1291       case DESTUID:
1292         return isSetDestuid();
1293       case FILE:
1294         return isSetFile();
1295       case RULE:
1296         return isSetRule();
1297       case TID:
1298         return isSetTid();
1299       case ACTION:
1300         return isSetAction();
1301       case CODE:
1302         return isSetCode();
1303       case RESULTINFO:
1304         return isSetResultinfo();
1305       case GLOBALSTEP:
1306         return isSetGlobalstep();
1307       case GLOBALLASTSTEP:
1308         return isSetGloballaststep();
1309       case STEP:
1310         return isSetStep();
1311       case RANK:
1312         return isSetRank();
1313       case RETRIEVEMODE:
1314         return isSetRetrievemode();
1315       case ISMOVED:
1316         return isSetIsmoved();
1317       case ORIGINALFILENAME:
1318         return isSetOriginalfilename();
1319       case BLOCKSIZE:
1320         return isSetBlocksize();
1321       case MODETRANSFER:
1322         return isSetModetransfer();
1323       case START:
1324         return isSetStart();
1325       case STOP:
1326         return isSetStop();
1327     }
1328     throw new IllegalStateException();
1329   }
1330 
1331   @Override
1332   public final boolean equals(final Object that) {
1333     if (that == null) {
1334       return false;
1335     }
1336     if (that instanceof R66Result) {
1337       return equals((R66Result) that);
1338     }
1339     return false;
1340   }
1341 
1342   public final boolean equals(final R66Result that) {
1343     if (that == null) {
1344       return false;
1345     }
1346 
1347     final boolean this_present_mode = isSetMode();
1348     final boolean that_present_mode = that.isSetMode();
1349     if (this_present_mode || that_present_mode) {
1350       if (!(this_present_mode && that_present_mode)) {
1351         return false;
1352       }
1353       if (mode != that.mode) {
1354         return false;
1355       }
1356     }
1357 
1358     final boolean this_present_fromuid = isSetFromuid();
1359     final boolean that_present_fromuid = that.isSetFromuid();
1360     if (this_present_fromuid || that_present_fromuid) {
1361       if (!(this_present_fromuid && that_present_fromuid)) {
1362         return false;
1363       }
1364       if (!fromuid.equals(that.fromuid)) {
1365         return false;
1366       }
1367     }
1368 
1369     final boolean this_present_destuid = isSetDestuid();
1370     final boolean that_present_destuid = that.isSetDestuid();
1371     if (this_present_destuid || that_present_destuid) {
1372       if (!(this_present_destuid && that_present_destuid)) {
1373         return false;
1374       }
1375       if (!destuid.equals(that.destuid)) {
1376         return false;
1377       }
1378     }
1379 
1380     final boolean this_present_file = isSetFile();
1381     final boolean that_present_file = that.isSetFile();
1382     if (this_present_file || that_present_file) {
1383       if (!(this_present_file && that_present_file)) {
1384         return false;
1385       }
1386       if (!file.equals(that.file)) {
1387         return false;
1388       }
1389     }
1390 
1391     final boolean this_present_rule = isSetRule();
1392     final boolean that_present_rule = that.isSetRule();
1393     if (this_present_rule || that_present_rule) {
1394       if (!(this_present_rule && that_present_rule)) {
1395         return false;
1396       }
1397       if (!rule.equals(that.rule)) {
1398         return false;
1399       }
1400     }
1401 
1402     final boolean this_present_tid = isSetTid();
1403     final boolean that_present_tid = that.isSetTid();
1404     if (this_present_tid || that_present_tid) {
1405       if (!(this_present_tid && that_present_tid)) {
1406         return false;
1407       }
1408       if (tid != that.tid) {
1409         return false;
1410       }
1411     }
1412 
1413     final boolean this_present_action = isSetAction();
1414     final boolean that_present_action = that.isSetAction();
1415     if (this_present_action || that_present_action) {
1416       if (!(this_present_action && that_present_action)) {
1417         return false;
1418       }
1419       if (action != that.action) {
1420         return false;
1421       }
1422     }
1423 
1424     final boolean this_present_code = isSetCode();
1425     final boolean that_present_code = that.isSetCode();
1426     if (this_present_code || that_present_code) {
1427       if (!(this_present_code && that_present_code)) {
1428         return false;
1429       }
1430       if (code != that.code) {
1431         return false;
1432       }
1433     }
1434 
1435     final boolean this_present_resultinfo = isSetResultinfo();
1436     final boolean that_present_resultinfo = that.isSetResultinfo();
1437     if (this_present_resultinfo || that_present_resultinfo) {
1438       if (!(this_present_resultinfo && that_present_resultinfo)) {
1439         return false;
1440       }
1441       if (!resultinfo.equals(that.resultinfo)) {
1442         return false;
1443       }
1444     }
1445 
1446     final boolean this_present_globalstep = isSetGlobalstep();
1447     final boolean that_present_globalstep = that.isSetGlobalstep();
1448     if (this_present_globalstep || that_present_globalstep) {
1449       if (!(this_present_globalstep && that_present_globalstep)) {
1450         return false;
1451       }
1452       if (globalstep != that.globalstep) {
1453         return false;
1454       }
1455     }
1456 
1457     final boolean this_present_globallaststep = isSetGloballaststep();
1458     final boolean that_present_globallaststep = that.isSetGloballaststep();
1459     if (this_present_globallaststep || that_present_globallaststep) {
1460       if (!(this_present_globallaststep && that_present_globallaststep)) {
1461         return false;
1462       }
1463       if (globallaststep != that.globallaststep) {
1464         return false;
1465       }
1466     }
1467 
1468     final boolean this_present_step = isSetStep();
1469     final boolean that_present_step = that.isSetStep();
1470     if (this_present_step || that_present_step) {
1471       if (!(this_present_step && that_present_step)) {
1472         return false;
1473       }
1474       if (step != that.step) {
1475         return false;
1476       }
1477     }
1478 
1479     final boolean this_present_rank = isSetRank();
1480     final boolean that_present_rank = that.isSetRank();
1481     if (this_present_rank || that_present_rank) {
1482       if (!(this_present_rank && that_present_rank)) {
1483         return false;
1484       }
1485       if (rank != that.rank) {
1486         return false;
1487       }
1488     }
1489 
1490     final boolean this_present_retrievemode = isSetRetrievemode();
1491     final boolean that_present_retrievemode = that.isSetRetrievemode();
1492     if (this_present_retrievemode || that_present_retrievemode) {
1493       if (!(this_present_retrievemode && that_present_retrievemode)) {
1494         return false;
1495       }
1496       if (retrievemode != that.retrievemode) {
1497         return false;
1498       }
1499     }
1500 
1501     final boolean this_present_ismoved = isSetIsmoved();
1502     final boolean that_present_ismoved = that.isSetIsmoved();
1503     if (this_present_ismoved || that_present_ismoved) {
1504       if (!(this_present_ismoved && that_present_ismoved)) {
1505         return false;
1506       }
1507       if (ismoved != that.ismoved) {
1508         return false;
1509       }
1510     }
1511 
1512     final boolean this_present_originalfilename = isSetOriginalfilename();
1513     final boolean that_present_originalfilename = that.isSetOriginalfilename();
1514     if (this_present_originalfilename || that_present_originalfilename) {
1515       if (!(this_present_originalfilename && that_present_originalfilename)) {
1516         return false;
1517       }
1518       if (!originalfilename.equals(that.originalfilename)) {
1519         return false;
1520       }
1521     }
1522 
1523     final boolean this_present_blocksize = isSetBlocksize();
1524     final boolean that_present_blocksize = that.isSetBlocksize();
1525     if (this_present_blocksize || that_present_blocksize) {
1526       if (!(this_present_blocksize && that_present_blocksize)) {
1527         return false;
1528       }
1529       if (blocksize != that.blocksize) {
1530         return false;
1531       }
1532     }
1533 
1534     final boolean this_present_modetransfer = isSetModetransfer();
1535     final boolean that_present_modetransfer = that.isSetModetransfer();
1536     if (this_present_modetransfer || that_present_modetransfer) {
1537       if (!(this_present_modetransfer && that_present_modetransfer)) {
1538         return false;
1539       }
1540       if (modetransfer != that.modetransfer) {
1541         return false;
1542       }
1543     }
1544 
1545     final boolean this_present_start = isSetStart();
1546     final boolean that_present_start = that.isSetStart();
1547     if (this_present_start || that_present_start) {
1548       if (!(this_present_start && that_present_start)) {
1549         return false;
1550       }
1551       if (!start.equals(that.start)) {
1552         return false;
1553       }
1554     }
1555 
1556     final boolean this_present_stop = isSetStop();
1557     final boolean that_present_stop = that.isSetStop();
1558     if (this_present_stop || that_present_stop) {
1559       if (!(this_present_stop && that_present_stop)) {
1560         return false;
1561       }
1562       return stop.equals(that.stop);
1563     }
1564 
1565     return true;
1566   }
1567 
1568   @Override
1569   public final int hashCode() {
1570     return 0;
1571   }
1572 
1573   @Override
1574   public final int compareTo(final R66Result other) {
1575     if (!getClass().equals(other.getClass())) {
1576       return getClass().getName().compareTo(other.getClass().getName());
1577     }
1578 
1579     int lastComparison;
1580 
1581     lastComparison = Boolean.valueOf(isSetMode()).compareTo(other.isSetMode());
1582     if (lastComparison != 0) {
1583       return lastComparison;
1584     }
1585     if (isSetMode()) {
1586       lastComparison = TBaseHelper.compareTo(mode, other.mode);
1587       if (lastComparison != 0) {
1588         return lastComparison;
1589       }
1590     }
1591     lastComparison =
1592         Boolean.valueOf(isSetFromuid()).compareTo(other.isSetFromuid());
1593     if (lastComparison != 0) {
1594       return lastComparison;
1595     }
1596     if (isSetFromuid()) {
1597       lastComparison = TBaseHelper.compareTo(fromuid, other.fromuid);
1598       if (lastComparison != 0) {
1599         return lastComparison;
1600       }
1601     }
1602     lastComparison =
1603         Boolean.valueOf(isSetDestuid()).compareTo(other.isSetDestuid());
1604     if (lastComparison != 0) {
1605       return lastComparison;
1606     }
1607     if (isSetDestuid()) {
1608       lastComparison = TBaseHelper.compareTo(destuid, other.destuid);
1609       if (lastComparison != 0) {
1610         return lastComparison;
1611       }
1612     }
1613     lastComparison = Boolean.valueOf(isSetFile()).compareTo(other.isSetFile());
1614     if (lastComparison != 0) {
1615       return lastComparison;
1616     }
1617     if (isSetFile()) {
1618       lastComparison = TBaseHelper.compareTo(file, other.file);
1619       if (lastComparison != 0) {
1620         return lastComparison;
1621       }
1622     }
1623     lastComparison = Boolean.valueOf(isSetRule()).compareTo(other.isSetRule());
1624     if (lastComparison != 0) {
1625       return lastComparison;
1626     }
1627     if (isSetRule()) {
1628       lastComparison = TBaseHelper.compareTo(rule, other.rule);
1629       if (lastComparison != 0) {
1630         return lastComparison;
1631       }
1632     }
1633     lastComparison = Boolean.valueOf(isSetTid()).compareTo(other.isSetTid());
1634     if (lastComparison != 0) {
1635       return lastComparison;
1636     }
1637     if (isSetTid()) {
1638       lastComparison = TBaseHelper.compareTo(tid, other.tid);
1639       if (lastComparison != 0) {
1640         return lastComparison;
1641       }
1642     }
1643     lastComparison =
1644         Boolean.valueOf(isSetAction()).compareTo(other.isSetAction());
1645     if (lastComparison != 0) {
1646       return lastComparison;
1647     }
1648     if (isSetAction()) {
1649       lastComparison = TBaseHelper.compareTo(action, other.action);
1650       if (lastComparison != 0) {
1651         return lastComparison;
1652       }
1653     }
1654     lastComparison = Boolean.valueOf(isSetCode()).compareTo(other.isSetCode());
1655     if (lastComparison != 0) {
1656       return lastComparison;
1657     }
1658     if (isSetCode()) {
1659       lastComparison = TBaseHelper.compareTo(code, other.code);
1660       if (lastComparison != 0) {
1661         return lastComparison;
1662       }
1663     }
1664     lastComparison =
1665         Boolean.valueOf(isSetResultinfo()).compareTo(other.isSetResultinfo());
1666     if (lastComparison != 0) {
1667       return lastComparison;
1668     }
1669     if (isSetResultinfo()) {
1670       lastComparison = TBaseHelper.compareTo(resultinfo, other.resultinfo);
1671       if (lastComparison != 0) {
1672         return lastComparison;
1673       }
1674     }
1675     lastComparison =
1676         Boolean.valueOf(isSetGlobalstep()).compareTo(other.isSetGlobalstep());
1677     if (lastComparison != 0) {
1678       return lastComparison;
1679     }
1680     if (isSetGlobalstep()) {
1681       lastComparison = TBaseHelper.compareTo(globalstep, other.globalstep);
1682       if (lastComparison != 0) {
1683         return lastComparison;
1684       }
1685     }
1686     lastComparison = Boolean.valueOf(isSetGloballaststep())
1687                             .compareTo(other.isSetGloballaststep());
1688     if (lastComparison != 0) {
1689       return lastComparison;
1690     }
1691     if (isSetGloballaststep()) {
1692       lastComparison =
1693           TBaseHelper.compareTo(globallaststep, other.globallaststep);
1694       if (lastComparison != 0) {
1695         return lastComparison;
1696       }
1697     }
1698     lastComparison = Boolean.valueOf(isSetStep()).compareTo(other.isSetStep());
1699     if (lastComparison != 0) {
1700       return lastComparison;
1701     }
1702     if (isSetStep()) {
1703       lastComparison = TBaseHelper.compareTo(step, other.step);
1704       if (lastComparison != 0) {
1705         return lastComparison;
1706       }
1707     }
1708     lastComparison = Boolean.valueOf(isSetRank()).compareTo(other.isSetRank());
1709     if (lastComparison != 0) {
1710       return lastComparison;
1711     }
1712     if (isSetRank()) {
1713       lastComparison = TBaseHelper.compareTo(rank, other.rank);
1714       if (lastComparison != 0) {
1715         return lastComparison;
1716       }
1717     }
1718     lastComparison = Boolean.valueOf(isSetRetrievemode())
1719                             .compareTo(other.isSetRetrievemode());
1720     if (lastComparison != 0) {
1721       return lastComparison;
1722     }
1723     if (isSetRetrievemode()) {
1724       lastComparison = TBaseHelper.compareTo(retrievemode, other.retrievemode);
1725       if (lastComparison != 0) {
1726         return lastComparison;
1727       }
1728     }
1729     lastComparison =
1730         Boolean.valueOf(isSetIsmoved()).compareTo(other.isSetIsmoved());
1731     if (lastComparison != 0) {
1732       return lastComparison;
1733     }
1734     if (isSetIsmoved()) {
1735       lastComparison = TBaseHelper.compareTo(ismoved, other.ismoved);
1736       if (lastComparison != 0) {
1737         return lastComparison;
1738       }
1739     }
1740     lastComparison = Boolean.valueOf(isSetOriginalfilename())
1741                             .compareTo(other.isSetOriginalfilename());
1742     if (lastComparison != 0) {
1743       return lastComparison;
1744     }
1745     if (isSetOriginalfilename()) {
1746       lastComparison =
1747           TBaseHelper.compareTo(originalfilename, other.originalfilename);
1748       if (lastComparison != 0) {
1749         return lastComparison;
1750       }
1751     }
1752     lastComparison =
1753         Boolean.valueOf(isSetBlocksize()).compareTo(other.isSetBlocksize());
1754     if (lastComparison != 0) {
1755       return lastComparison;
1756     }
1757     if (isSetBlocksize()) {
1758       lastComparison = TBaseHelper.compareTo(blocksize, other.blocksize);
1759       if (lastComparison != 0) {
1760         return lastComparison;
1761       }
1762     }
1763     lastComparison = Boolean.valueOf(isSetModetransfer())
1764                             .compareTo(other.isSetModetransfer());
1765     if (lastComparison != 0) {
1766       return lastComparison;
1767     }
1768     if (isSetModetransfer()) {
1769       lastComparison = TBaseHelper.compareTo(modetransfer, other.modetransfer);
1770       if (lastComparison != 0) {
1771         return lastComparison;
1772       }
1773     }
1774     lastComparison =
1775         Boolean.valueOf(isSetStart()).compareTo(other.isSetStart());
1776     if (lastComparison != 0) {
1777       return lastComparison;
1778     }
1779     if (isSetStart()) {
1780       lastComparison = TBaseHelper.compareTo(start, other.start);
1781       if (lastComparison != 0) {
1782         return lastComparison;
1783       }
1784     }
1785     lastComparison = Boolean.valueOf(isSetStop()).compareTo(other.isSetStop());
1786     if (lastComparison != 0) {
1787       return lastComparison;
1788     }
1789     if (isSetStop()) {
1790       lastComparison = TBaseHelper.compareTo(stop, other.stop);
1791       return lastComparison;
1792     }
1793     return 0;
1794   }
1795 
1796   @Override
1797   public final _Fields fieldForId(final int fieldId) {
1798     return _Fields.findByThriftId(fieldId);
1799   }
1800 
1801   @Override
1802   public final void read(final TProtocol iprot) throws TException {
1803     schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
1804   }
1805 
1806   @Override
1807   public final void write(final TProtocol oprot) throws TException {
1808     schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
1809   }
1810 
1811   @Override
1812   public final String toString() {
1813     final StringBuilder sb = new StringBuilder("R66Result(");
1814 
1815     sb.append("mode:");
1816     if (mode == null) {
1817       sb.append("null");
1818     } else {
1819       sb.append(mode);
1820     }
1821     if (isSetFromuid()) {
1822       sb.append(", ");
1823       sb.append("fromuid:");
1824       if (fromuid == null) {
1825         sb.append("null");
1826       } else {
1827         sb.append(fromuid);
1828       }
1829     }
1830     if (isSetDestuid()) {
1831       sb.append(", ");
1832       sb.append("destuid:");
1833       if (destuid == null) {
1834         sb.append("null");
1835       } else {
1836         sb.append(destuid);
1837       }
1838     }
1839     if (isSetFile()) {
1840       sb.append(", ");
1841       sb.append("file:");
1842       if (file == null) {
1843         sb.append("null");
1844       } else {
1845         sb.append(file);
1846       }
1847     }
1848     if (isSetRule()) {
1849       sb.append(", ");
1850       sb.append("rule:");
1851       if (rule == null) {
1852         sb.append("null");
1853       } else {
1854         sb.append(rule);
1855       }
1856     }
1857     if (isSetTid()) {
1858       sb.append(", ");
1859       sb.append("tid:").append(tid);
1860     }
1861     if (isSetAction()) {
1862       sb.append(", ");
1863       sb.append("action:");
1864       if (action == null) {
1865         sb.append("null");
1866       } else {
1867         sb.append(action);
1868       }
1869     }
1870     sb.append(", ");
1871     sb.append("code:");
1872     if (code == null) {
1873       sb.append("null");
1874     } else {
1875       sb.append(code);
1876     }
1877     sb.append(", ");
1878     sb.append("resultinfo:");
1879     if (resultinfo == null) {
1880       sb.append("null");
1881     } else {
1882       sb.append(resultinfo);
1883     }
1884     if (isSetGlobalstep()) {
1885       sb.append(", ");
1886       sb.append("globalstep:").append(globalstep);
1887     }
1888     if (isSetGloballaststep()) {
1889       sb.append(", ");
1890       sb.append("globallaststep:").append(globallaststep);
1891     }
1892     if (isSetStep()) {
1893       sb.append(", ");
1894       sb.append("step:").append(step);
1895     }
1896     if (isSetRank()) {
1897       sb.append(", ");
1898       sb.append("rank:").append(rank);
1899     }
1900     if (isSetRetrievemode()) {
1901       sb.append(", ");
1902       sb.append("retrievemode:").append(retrievemode);
1903     }
1904     if (isSetIsmoved()) {
1905       sb.append(", ");
1906       sb.append("ismoved:").append(ismoved);
1907     }
1908     if (isSetOriginalfilename()) {
1909       sb.append(", ");
1910       sb.append("originalfilename:");
1911       if (originalfilename == null) {
1912         sb.append("null");
1913       } else {
1914         sb.append(originalfilename);
1915       }
1916     }
1917     if (isSetBlocksize()) {
1918       sb.append(", ");
1919       sb.append("blocksize:").append(blocksize);
1920     }
1921     if (isSetModetransfer()) {
1922       sb.append(", ");
1923       sb.append("modetransfer:").append(modetransfer);
1924     }
1925     if (isSetStart()) {
1926       sb.append(", ");
1927       sb.append("start:");
1928       if (start == null) {
1929         sb.append("null");
1930       } else {
1931         sb.append(start);
1932       }
1933     }
1934     if (isSetStop()) {
1935       sb.append(", ");
1936       sb.append("stop:");
1937       if (stop == null) {
1938         sb.append("null");
1939       } else {
1940         sb.append(stop);
1941       }
1942     }
1943     sb.append(')');
1944     return sb.toString();
1945   }
1946 
1947   public final void validate() throws TException {
1948     // check for required fields
1949     if (mode == null) {
1950       throw new TProtocolException(
1951           "Required field 'mode' was not present! Struct: " + this);
1952     }
1953     if (code == null) {
1954       throw new TProtocolException(
1955           "Required field 'code' was not present! Struct: " + this);
1956     }
1957     if (resultinfo == null) {
1958       throw new TProtocolException(
1959           "Required field 'resultinfo' was not present! Struct: " + this);
1960     }
1961     // check for sub-struct validity
1962   }
1963 
1964   private final void writeObject(final ObjectOutputStream out)
1965       throws IOException {
1966     try {
1967       write(new TCompactProtocol(new TIOStreamTransport(out)));
1968     } catch (final TException te) {
1969       throw new IOException(te);
1970     }
1971   }
1972 
1973   private final void readObject(final ObjectInputStream in)
1974       throws IOException, ClassNotFoundException {
1975     try {
1976       // it doesn't seem like you should have to do this, but java serialization is wacky, and
1977       // doesn't call the default constructor.
1978       issetBitfield = 0;
1979       read(new TCompactProtocol(new TIOStreamTransport(in)));
1980     } catch (final TException te) {
1981       throw new IOException(te);
1982     }
1983   }
1984 
1985   private static class R66ResultStandardSchemeFactory implements SchemeFactory {
1986     @Override
1987     public final R66ResultStandardScheme getScheme() {
1988       return new R66ResultStandardScheme();
1989     }
1990   }
1991 
1992   private static class R66ResultStandardScheme
1993       extends StandardScheme<R66Result> {
1994 
1995     @Override
1996     public final void read(final TProtocol iprot, final R66Result struct)
1997         throws TException {
1998       TField schemeField;
1999       iprot.readStructBegin();
2000       while (true) {
2001         schemeField = iprot.readFieldBegin();
2002         if (schemeField.type == TType.STOP) {
2003           break;
2004         }
2005         switch (schemeField.id) {
2006           case 1: // MODE
2007             if (schemeField.type == TType.I32) {
2008               struct.mode = RequestMode.findByValue(iprot.readI32());
2009               struct.setModeIsSet(true);
2010             } else {
2011               TProtocolUtil.skip(iprot, schemeField.type);
2012             }
2013             break;
2014           case 2: // FROMUID
2015             if (schemeField.type == TType.STRING) {
2016               struct.fromuid = iprot.readString();
2017               struct.setFromuidIsSet(true);
2018             } else {
2019               TProtocolUtil.skip(iprot, schemeField.type);
2020             }
2021             break;
2022           case 3: // DESTUID
2023             if (schemeField.type == TType.STRING) {
2024               struct.destuid = iprot.readString();
2025               struct.setDestuidIsSet(true);
2026             } else {
2027               TProtocolUtil.skip(iprot, schemeField.type);
2028             }
2029             break;
2030           case 4: // FILE
2031             if (schemeField.type == TType.STRING) {
2032               struct.file = iprot.readString();
2033               struct.setFileIsSet(true);
2034             } else {
2035               TProtocolUtil.skip(iprot, schemeField.type);
2036             }
2037             break;
2038           case 5: // RULE
2039             if (schemeField.type == TType.STRING) {
2040               struct.rule = iprot.readString();
2041               struct.setRuleIsSet(true);
2042             } else {
2043               TProtocolUtil.skip(iprot, schemeField.type);
2044             }
2045             break;
2046           case 20: // TID
2047             if (schemeField.type == TType.I64) {
2048               struct.tid = iprot.readI64();
2049               struct.setTidIsSet(true);
2050             } else {
2051               TProtocolUtil.skip(iprot, schemeField.type);
2052             }
2053             break;
2054           case 21: // ACTION
2055             if (schemeField.type == TType.I32) {
2056               struct.action = Action.findByValue(iprot.readI32());
2057               struct.setActionIsSet(true);
2058             } else {
2059               TProtocolUtil.skip(iprot, schemeField.type);
2060             }
2061             break;
2062           case 30: // CODE
2063             if (schemeField.type == TType.I32) {
2064               struct.code = ErrorCode.findByValue(iprot.readI32());
2065               struct.setCodeIsSet(true);
2066             } else {
2067               TProtocolUtil.skip(iprot, schemeField.type);
2068             }
2069             break;
2070           case 31: // RESULTINFO
2071             if (schemeField.type == TType.STRING) {
2072               struct.resultinfo = iprot.readString();
2073               struct.setResultinfoIsSet(true);
2074             } else {
2075               TProtocolUtil.skip(iprot, schemeField.type);
2076             }
2077             break;
2078           case 32: // GLOBALSTEP
2079             if (schemeField.type == TType.I32) {
2080               struct.globalstep = iprot.readI32();
2081               struct.setGlobalstepIsSet(true);
2082             } else {
2083               TProtocolUtil.skip(iprot, schemeField.type);
2084             }
2085             break;
2086           case 33: // GLOBALLASTSTEP
2087             if (schemeField.type == TType.I32) {
2088               struct.globallaststep = iprot.readI32();
2089               struct.setGloballaststepIsSet(true);
2090             } else {
2091               TProtocolUtil.skip(iprot, schemeField.type);
2092             }
2093             break;
2094           case 34: // STEP
2095             if (schemeField.type == TType.I32) {
2096               struct.step = iprot.readI32();
2097               struct.setStepIsSet(true);
2098             } else {
2099               TProtocolUtil.skip(iprot, schemeField.type);
2100             }
2101             break;
2102           case 35: // RANK
2103             if (schemeField.type == TType.I32) {
2104               struct.rank = iprot.readI32();
2105               struct.setRankIsSet(true);
2106             } else {
2107               TProtocolUtil.skip(iprot, schemeField.type);
2108             }
2109             break;
2110           case 36: // RETRIEVEMODE
2111             if (schemeField.type == TType.BOOL) {
2112               struct.retrievemode = iprot.readBool();
2113               struct.setRetrievemodeIsSet(true);
2114             } else {
2115               TProtocolUtil.skip(iprot, schemeField.type);
2116             }
2117             break;
2118           case 37: // ISMOVED
2119             if (schemeField.type == TType.BOOL) {
2120               struct.ismoved = iprot.readBool();
2121               struct.setIsmovedIsSet(true);
2122             } else {
2123               TProtocolUtil.skip(iprot, schemeField.type);
2124             }
2125             break;
2126           case 38: // ORIGINALFILENAME
2127             if (schemeField.type == TType.STRING) {
2128               struct.originalfilename = iprot.readString();
2129               struct.setOriginalfilenameIsSet(true);
2130             } else {
2131               TProtocolUtil.skip(iprot, schemeField.type);
2132             }
2133             break;
2134           case 39: // BLOCKSIZE
2135             if (schemeField.type == TType.I32) {
2136               struct.blocksize = iprot.readI32();
2137               struct.setBlocksizeIsSet(true);
2138             } else {
2139               TProtocolUtil.skip(iprot, schemeField.type);
2140             }
2141             break;
2142           case 40: // MODETRANSFER
2143             if (schemeField.type == TType.I32) {
2144               struct.modetransfer = iprot.readI32();
2145               struct.setModetransferIsSet(true);
2146             } else {
2147               TProtocolUtil.skip(iprot, schemeField.type);
2148             }
2149             break;
2150           case 41: // START
2151             if (schemeField.type == TType.STRING) {
2152               struct.start = iprot.readString();
2153               struct.setStartIsSet(true);
2154             } else {
2155               TProtocolUtil.skip(iprot, schemeField.type);
2156             }
2157             break;
2158           case 42: // STOP
2159             if (schemeField.type == TType.STRING) {
2160               struct.stop = iprot.readString();
2161               struct.setStopIsSet(true);
2162             } else {
2163               TProtocolUtil.skip(iprot, schemeField.type);
2164             }
2165             break;
2166           default:
2167             TProtocolUtil.skip(iprot, schemeField.type);
2168         }
2169         iprot.readFieldEnd();
2170       }
2171       iprot.readStructEnd();
2172 
2173       // check for required fields of primitive type, which can't be checked in the validate
2174       // method
2175       struct.validate();
2176     }
2177 
2178     @Override
2179     public final void write(final TProtocol oprot, final R66Result struct)
2180         throws TException {
2181       struct.validate();
2182 
2183       oprot.writeStructBegin(STRUCT_DESC);
2184       if (struct.mode != null) {
2185         oprot.writeFieldBegin(MODE_FIELD_DESC);
2186         oprot.writeI32(struct.mode.getValue());
2187         oprot.writeFieldEnd();
2188       }
2189       if (struct.fromuid != null && struct.isSetFromuid()) {
2190         oprot.writeFieldBegin(FROMUID_FIELD_DESC);
2191         oprot.writeString(struct.fromuid);
2192         oprot.writeFieldEnd();
2193       }
2194       if (struct.destuid != null && struct.isSetDestuid()) {
2195         oprot.writeFieldBegin(DESTUID_FIELD_DESC);
2196         oprot.writeString(struct.destuid);
2197         oprot.writeFieldEnd();
2198       }
2199       if (struct.file != null && struct.isSetFile()) {
2200         oprot.writeFieldBegin(FILE_FIELD_DESC);
2201         oprot.writeString(struct.file);
2202         oprot.writeFieldEnd();
2203       }
2204       if (struct.rule != null && struct.isSetRule()) {
2205         oprot.writeFieldBegin(RULE_FIELD_DESC);
2206         oprot.writeString(struct.rule);
2207         oprot.writeFieldEnd();
2208       }
2209       if (struct.isSetTid()) {
2210         oprot.writeFieldBegin(TID_FIELD_DESC);
2211         oprot.writeI64(struct.tid);
2212         oprot.writeFieldEnd();
2213       }
2214       if (struct.action != null && struct.isSetAction()) {
2215         oprot.writeFieldBegin(ACTION_FIELD_DESC);
2216         oprot.writeI32(struct.action.getValue());
2217         oprot.writeFieldEnd();
2218       }
2219       if (struct.code != null) {
2220         oprot.writeFieldBegin(CODE_FIELD_DESC);
2221         oprot.writeI32(struct.code.getValue());
2222         oprot.writeFieldEnd();
2223       }
2224       if (struct.resultinfo != null) {
2225         oprot.writeFieldBegin(RESULTINFO_FIELD_DESC);
2226         oprot.writeString(struct.resultinfo);
2227         oprot.writeFieldEnd();
2228       }
2229       if (struct.isSetGlobalstep()) {
2230         oprot.writeFieldBegin(GLOBALSTEP_FIELD_DESC);
2231         oprot.writeI32(struct.globalstep);
2232         oprot.writeFieldEnd();
2233       }
2234       if (struct.isSetGloballaststep()) {
2235         oprot.writeFieldBegin(GLOBALLASTSTEP_FIELD_DESC);
2236         oprot.writeI32(struct.globallaststep);
2237         oprot.writeFieldEnd();
2238       }
2239       if (struct.isSetStep()) {
2240         oprot.writeFieldBegin(STEP_FIELD_DESC);
2241         oprot.writeI32(struct.step);
2242         oprot.writeFieldEnd();
2243       }
2244       if (struct.isSetRank()) {
2245         oprot.writeFieldBegin(RANK_FIELD_DESC);
2246         oprot.writeI32(struct.rank);
2247         oprot.writeFieldEnd();
2248       }
2249       if (struct.isSetRetrievemode()) {
2250         oprot.writeFieldBegin(RETRIEVEMODE_FIELD_DESC);
2251         oprot.writeBool(struct.retrievemode);
2252         oprot.writeFieldEnd();
2253       }
2254       if (struct.isSetIsmoved()) {
2255         oprot.writeFieldBegin(ISMOVED_FIELD_DESC);
2256         oprot.writeBool(struct.ismoved);
2257         oprot.writeFieldEnd();
2258       }
2259       if (struct.originalfilename != null && struct.isSetOriginalfilename()) {
2260         oprot.writeFieldBegin(ORIGINALFILENAME_FIELD_DESC);
2261         oprot.writeString(struct.originalfilename);
2262         oprot.writeFieldEnd();
2263       }
2264       if (struct.isSetBlocksize()) {
2265         oprot.writeFieldBegin(BLOCKSIZE_FIELD_DESC);
2266         oprot.writeI32(struct.blocksize);
2267         oprot.writeFieldEnd();
2268       }
2269       if (struct.isSetModetransfer()) {
2270         oprot.writeFieldBegin(MODETRANSFER_FIELD_DESC);
2271         oprot.writeI32(struct.modetransfer);
2272         oprot.writeFieldEnd();
2273       }
2274       if (struct.start != null && struct.isSetStart()) {
2275         oprot.writeFieldBegin(START_FIELD_DESC);
2276         oprot.writeString(struct.start);
2277         oprot.writeFieldEnd();
2278       }
2279       if (struct.stop != null && struct.isSetStop()) {
2280         oprot.writeFieldBegin(STOP_FIELD_DESC);
2281         oprot.writeString(struct.stop);
2282         oprot.writeFieldEnd();
2283       }
2284       oprot.writeFieldStop();
2285       oprot.writeStructEnd();
2286     }
2287 
2288   }
2289 
2290   private static class R66ResultTupleSchemeFactory implements SchemeFactory {
2291     @Override
2292     public final R66ResultTupleScheme getScheme() {
2293       return new R66ResultTupleScheme();
2294     }
2295   }
2296 
2297   private static class R66ResultTupleScheme extends TupleScheme<R66Result> {
2298 
2299     @Override
2300     public final void write(final TProtocol prot, final R66Result struct)
2301         throws TException {
2302       final TTupleProtocol oprot = (TTupleProtocol) prot;
2303       oprot.writeI32(struct.mode.getValue());
2304       oprot.writeI32(struct.code.getValue());
2305       oprot.writeString(struct.resultinfo);
2306       final BitSet optionals = new BitSet();
2307       if (struct.isSetFromuid()) {
2308         optionals.set(0);
2309       }
2310       if (struct.isSetDestuid()) {
2311         optionals.set(1);
2312       }
2313       if (struct.isSetFile()) {
2314         optionals.set(2);
2315       }
2316       if (struct.isSetRule()) {
2317         optionals.set(3);
2318       }
2319       if (struct.isSetTid()) {
2320         optionals.set(4);
2321       }
2322       if (struct.isSetAction()) {
2323         optionals.set(5);
2324       }
2325       if (struct.isSetGlobalstep()) {
2326         optionals.set(6);
2327       }
2328       if (struct.isSetGloballaststep()) {
2329         optionals.set(7);
2330       }
2331       if (struct.isSetStep()) {
2332         optionals.set(8);
2333       }
2334       if (struct.isSetRank()) {
2335         optionals.set(9);
2336       }
2337       if (struct.isSetRetrievemode()) {
2338         optionals.set(10);
2339       }
2340       if (struct.isSetIsmoved()) {
2341         optionals.set(11);
2342       }
2343       if (struct.isSetOriginalfilename()) {
2344         optionals.set(12);
2345       }
2346       if (struct.isSetBlocksize()) {
2347         optionals.set(13);
2348       }
2349       if (struct.isSetModetransfer()) {
2350         optionals.set(14);
2351       }
2352       if (struct.isSetStart()) {
2353         optionals.set(15);
2354       }
2355       if (struct.isSetStop()) {
2356         optionals.set(16);
2357       }
2358       oprot.writeBitSet(optionals, 17);
2359       if (struct.isSetFromuid()) {
2360         oprot.writeString(struct.fromuid);
2361       }
2362       if (struct.isSetDestuid()) {
2363         oprot.writeString(struct.destuid);
2364       }
2365       if (struct.isSetFile()) {
2366         oprot.writeString(struct.file);
2367       }
2368       if (struct.isSetRule()) {
2369         oprot.writeString(struct.rule);
2370       }
2371       if (struct.isSetTid()) {
2372         oprot.writeI64(struct.tid);
2373       }
2374       if (struct.isSetAction()) {
2375         oprot.writeI32(struct.action.getValue());
2376       }
2377       if (struct.isSetGlobalstep()) {
2378         oprot.writeI32(struct.globalstep);
2379       }
2380       if (struct.isSetGloballaststep()) {
2381         oprot.writeI32(struct.globallaststep);
2382       }
2383       if (struct.isSetStep()) {
2384         oprot.writeI32(struct.step);
2385       }
2386       if (struct.isSetRank()) {
2387         oprot.writeI32(struct.rank);
2388       }
2389       if (struct.isSetRetrievemode()) {
2390         oprot.writeBool(struct.retrievemode);
2391       }
2392       if (struct.isSetIsmoved()) {
2393         oprot.writeBool(struct.ismoved);
2394       }
2395       if (struct.isSetOriginalfilename()) {
2396         oprot.writeString(struct.originalfilename);
2397       }
2398       if (struct.isSetBlocksize()) {
2399         oprot.writeI32(struct.blocksize);
2400       }
2401       if (struct.isSetModetransfer()) {
2402         oprot.writeI32(struct.modetransfer);
2403       }
2404       if (struct.isSetStart()) {
2405         oprot.writeString(struct.start);
2406       }
2407       if (struct.isSetStop()) {
2408         oprot.writeString(struct.stop);
2409       }
2410     }
2411 
2412     @Override
2413     public final void read(final TProtocol prot, final R66Result struct)
2414         throws TException {
2415       final TTupleProtocol iprot = (TTupleProtocol) prot;
2416       struct.mode = RequestMode.findByValue(iprot.readI32());
2417       struct.setModeIsSet(true);
2418       struct.code = ErrorCode.findByValue(iprot.readI32());
2419       struct.setCodeIsSet(true);
2420       struct.resultinfo = iprot.readString();
2421       struct.setResultinfoIsSet(true);
2422       final BitSet incoming = iprot.readBitSet(17);
2423       if (incoming.get(0)) {
2424         struct.fromuid = iprot.readString();
2425         struct.setFromuidIsSet(true);
2426       }
2427       if (incoming.get(1)) {
2428         struct.destuid = iprot.readString();
2429         struct.setDestuidIsSet(true);
2430       }
2431       if (incoming.get(2)) {
2432         struct.file = iprot.readString();
2433         struct.setFileIsSet(true);
2434       }
2435       if (incoming.get(3)) {
2436         struct.rule = iprot.readString();
2437         struct.setRuleIsSet(true);
2438       }
2439       if (incoming.get(4)) {
2440         struct.tid = iprot.readI64();
2441         struct.setTidIsSet(true);
2442       }
2443       if (incoming.get(5)) {
2444         struct.action = Action.findByValue(iprot.readI32());
2445         struct.setActionIsSet(true);
2446       }
2447       if (incoming.get(6)) {
2448         struct.globalstep = iprot.readI32();
2449         struct.setGlobalstepIsSet(true);
2450       }
2451       if (incoming.get(7)) {
2452         struct.globallaststep = iprot.readI32();
2453         struct.setGloballaststepIsSet(true);
2454       }
2455       if (incoming.get(8)) {
2456         struct.step = iprot.readI32();
2457         struct.setStepIsSet(true);
2458       }
2459       if (incoming.get(9)) {
2460         struct.rank = iprot.readI32();
2461         struct.setRankIsSet(true);
2462       }
2463       if (incoming.get(10)) {
2464         struct.retrievemode = iprot.readBool();
2465         struct.setRetrievemodeIsSet(true);
2466       }
2467       if (incoming.get(11)) {
2468         struct.ismoved = iprot.readBool();
2469         struct.setIsmovedIsSet(true);
2470       }
2471       if (incoming.get(12)) {
2472         struct.originalfilename = iprot.readString();
2473         struct.setOriginalfilenameIsSet(true);
2474       }
2475       if (incoming.get(13)) {
2476         struct.blocksize = iprot.readI32();
2477         struct.setBlocksizeIsSet(true);
2478       }
2479       if (incoming.get(14)) {
2480         struct.modetransfer = iprot.readI32();
2481         struct.setModetransferIsSet(true);
2482       }
2483       if (incoming.get(15)) {
2484         struct.start = iprot.readString();
2485         struct.setStartIsSet(true);
2486       }
2487       if (incoming.get(16)) {
2488         struct.stop = iprot.readString();
2489         struct.setStopIsSet(true);
2490       }
2491     }
2492   }
2493 
2494 }