View Javadoc

1   /**
2    * Autogenerated by Thrift Compiler (0.9.0)
3    *
4    * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5    *  @generated
6    */
7   package org.apache.hadoop.hbase.thrift.generated;
8   
9   import org.apache.commons.lang.builder.HashCodeBuilder;
10  import org.apache.thrift.scheme.IScheme;
11  import org.apache.thrift.scheme.SchemeFactory;
12  import org.apache.thrift.scheme.StandardScheme;
13  
14  import org.apache.thrift.scheme.TupleScheme;
15  import org.apache.thrift.protocol.TTupleProtocol;
16  import org.apache.thrift.protocol.TProtocolException;
17  import org.apache.thrift.EncodingUtils;
18  import org.apache.thrift.TException;
19  import java.util.List;
20  import java.util.ArrayList;
21  import java.util.Map;
22  import java.util.HashMap;
23  import java.util.EnumMap;
24  import java.util.Set;
25  import java.util.HashSet;
26  import java.util.EnumSet;
27  import java.util.Collections;
28  import java.util.BitSet;
29  import java.nio.ByteBuffer;
30  import java.util.Arrays;
31  import org.slf4j.Logger;
32  import org.slf4j.LoggerFactory;
33  
34  /**
35   * An Append object is used to specify the parameters for performing the append operation.
36   */
37  public class TAppend implements org.apache.thrift.TBase<TAppend, TAppend._Fields>, java.io.Serializable, Cloneable {
38    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("TAppend");
39  
40    private static final org.apache.thrift.protocol.TField TABLE_FIELD_DESC = new org.apache.thrift.protocol.TField("table", org.apache.thrift.protocol.TType.STRING, (short)1);
41    private static final org.apache.thrift.protocol.TField ROW_FIELD_DESC = new org.apache.thrift.protocol.TField("row", org.apache.thrift.protocol.TType.STRING, (short)2);
42    private static final org.apache.thrift.protocol.TField COLUMNS_FIELD_DESC = new org.apache.thrift.protocol.TField("columns", org.apache.thrift.protocol.TType.LIST, (short)3);
43    private static final org.apache.thrift.protocol.TField VALUES_FIELD_DESC = new org.apache.thrift.protocol.TField("values", org.apache.thrift.protocol.TType.LIST, (short)4);
44  
45    private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
46    static {
47      schemes.put(StandardScheme.class, new TAppendStandardSchemeFactory());
48      schemes.put(TupleScheme.class, new TAppendTupleSchemeFactory());
49    }
50  
51    public ByteBuffer table; // required
52    public ByteBuffer row; // required
53    public List<ByteBuffer> columns; // required
54    public List<ByteBuffer> values; // required
55  
56    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
57    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
58      TABLE((short)1, "table"),
59      ROW((short)2, "row"),
60      COLUMNS((short)3, "columns"),
61      VALUES((short)4, "values");
62  
63      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
64  
65      static {
66        for (_Fields field : EnumSet.allOf(_Fields.class)) {
67          byName.put(field.getFieldName(), field);
68        }
69      }
70  
71      /**
72       * Find the _Fields constant that matches fieldId, or null if its not found.
73       */
74      public static _Fields findByThriftId(int fieldId) {
75        switch(fieldId) {
76          case 1: // TABLE
77            return TABLE;
78          case 2: // ROW
79            return ROW;
80          case 3: // COLUMNS
81            return COLUMNS;
82          case 4: // VALUES
83            return VALUES;
84          default:
85            return null;
86        }
87      }
88  
89      /**
90       * Find the _Fields constant that matches fieldId, throwing an exception
91       * if it is not found.
92       */
93      public static _Fields findByThriftIdOrThrow(int fieldId) {
94        _Fields fields = findByThriftId(fieldId);
95        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
96        return fields;
97      }
98  
99      /**
100      * Find the _Fields constant that matches name, or null if its not found.
101      */
102     public static _Fields findByName(String name) {
103       return byName.get(name);
104     }
105 
106     private final short _thriftId;
107     private final String _fieldName;
108 
109     _Fields(short thriftId, String fieldName) {
110       _thriftId = thriftId;
111       _fieldName = fieldName;
112     }
113 
114     public short getThriftFieldId() {
115       return _thriftId;
116     }
117 
118     public String getFieldName() {
119       return _fieldName;
120     }
121   }
122 
123   // isset id assignments
124   public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
125   static {
126     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
127     tmpMap.put(_Fields.TABLE, new org.apache.thrift.meta_data.FieldMetaData("table", org.apache.thrift.TFieldRequirementType.DEFAULT, 
128         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "Text")));
129     tmpMap.put(_Fields.ROW, new org.apache.thrift.meta_data.FieldMetaData("row", org.apache.thrift.TFieldRequirementType.DEFAULT, 
130         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "Text")));
131     tmpMap.put(_Fields.COLUMNS, new org.apache.thrift.meta_data.FieldMetaData("columns", org.apache.thrift.TFieldRequirementType.DEFAULT, 
132         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
133             new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING            , "Text"))));
134     tmpMap.put(_Fields.VALUES, new org.apache.thrift.meta_data.FieldMetaData("values", org.apache.thrift.TFieldRequirementType.DEFAULT, 
135         new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
136             new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING            , "Text"))));
137     metaDataMap = Collections.unmodifiableMap(tmpMap);
138     org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(TAppend.class, metaDataMap);
139   }
140 
141   public TAppend() {
142   }
143 
144   public TAppend(
145     ByteBuffer table,
146     ByteBuffer row,
147     List<ByteBuffer> columns,
148     List<ByteBuffer> values)
149   {
150     this();
151     this.table = table;
152     this.row = row;
153     this.columns = columns;
154     this.values = values;
155   }
156 
157   /**
158    * Performs a deep copy on <i>other</i>.
159    */
160   public TAppend(TAppend other) {
161     if (other.isSetTable()) {
162       this.table = other.table;
163     }
164     if (other.isSetRow()) {
165       this.row = other.row;
166     }
167     if (other.isSetColumns()) {
168       List<ByteBuffer> __this__columns = new ArrayList<ByteBuffer>();
169       for (ByteBuffer other_element : other.columns) {
170         __this__columns.add(other_element);
171       }
172       this.columns = __this__columns;
173     }
174     if (other.isSetValues()) {
175       List<ByteBuffer> __this__values = new ArrayList<ByteBuffer>();
176       for (ByteBuffer other_element : other.values) {
177         __this__values.add(other_element);
178       }
179       this.values = __this__values;
180     }
181   }
182 
183   public TAppend deepCopy() {
184     return new TAppend(this);
185   }
186 
187   @Override
188   public void clear() {
189     this.table = null;
190     this.row = null;
191     this.columns = null;
192     this.values = null;
193   }
194 
195   public byte[] getTable() {
196     setTable(org.apache.thrift.TBaseHelper.rightSize(table));
197     return table == null ? null : table.array();
198   }
199 
200   public ByteBuffer bufferForTable() {
201     return table;
202   }
203 
204   public TAppend setTable(byte[] table) {
205     setTable(table == null ? (ByteBuffer)null : ByteBuffer.wrap(table));
206     return this;
207   }
208 
209   public TAppend setTable(ByteBuffer table) {
210     this.table = table;
211     return this;
212   }
213 
214   public void unsetTable() {
215     this.table = null;
216   }
217 
218   /** Returns true if field table is set (has been assigned a value) and false otherwise */
219   public boolean isSetTable() {
220     return this.table != null;
221   }
222 
223   public void setTableIsSet(boolean value) {
224     if (!value) {
225       this.table = null;
226     }
227   }
228 
229   public byte[] getRow() {
230     setRow(org.apache.thrift.TBaseHelper.rightSize(row));
231     return row == null ? null : row.array();
232   }
233 
234   public ByteBuffer bufferForRow() {
235     return row;
236   }
237 
238   public TAppend setRow(byte[] row) {
239     setRow(row == null ? (ByteBuffer)null : ByteBuffer.wrap(row));
240     return this;
241   }
242 
243   public TAppend setRow(ByteBuffer row) {
244     this.row = row;
245     return this;
246   }
247 
248   public void unsetRow() {
249     this.row = null;
250   }
251 
252   /** Returns true if field row is set (has been assigned a value) and false otherwise */
253   public boolean isSetRow() {
254     return this.row != null;
255   }
256 
257   public void setRowIsSet(boolean value) {
258     if (!value) {
259       this.row = null;
260     }
261   }
262 
263   public int getColumnsSize() {
264     return (this.columns == null) ? 0 : this.columns.size();
265   }
266 
267   public java.util.Iterator<ByteBuffer> getColumnsIterator() {
268     return (this.columns == null) ? null : this.columns.iterator();
269   }
270 
271   public void addToColumns(ByteBuffer elem) {
272     if (this.columns == null) {
273       this.columns = new ArrayList<ByteBuffer>();
274     }
275     this.columns.add(elem);
276   }
277 
278   public List<ByteBuffer> getColumns() {
279     return this.columns;
280   }
281 
282   public TAppend setColumns(List<ByteBuffer> columns) {
283     this.columns = columns;
284     return this;
285   }
286 
287   public void unsetColumns() {
288     this.columns = null;
289   }
290 
291   /** Returns true if field columns is set (has been assigned a value) and false otherwise */
292   public boolean isSetColumns() {
293     return this.columns != null;
294   }
295 
296   public void setColumnsIsSet(boolean value) {
297     if (!value) {
298       this.columns = null;
299     }
300   }
301 
302   public int getValuesSize() {
303     return (this.values == null) ? 0 : this.values.size();
304   }
305 
306   public java.util.Iterator<ByteBuffer> getValuesIterator() {
307     return (this.values == null) ? null : this.values.iterator();
308   }
309 
310   public void addToValues(ByteBuffer elem) {
311     if (this.values == null) {
312       this.values = new ArrayList<ByteBuffer>();
313     }
314     this.values.add(elem);
315   }
316 
317   public List<ByteBuffer> getValues() {
318     return this.values;
319   }
320 
321   public TAppend setValues(List<ByteBuffer> values) {
322     this.values = values;
323     return this;
324   }
325 
326   public void unsetValues() {
327     this.values = null;
328   }
329 
330   /** Returns true if field values is set (has been assigned a value) and false otherwise */
331   public boolean isSetValues() {
332     return this.values != null;
333   }
334 
335   public void setValuesIsSet(boolean value) {
336     if (!value) {
337       this.values = null;
338     }
339   }
340 
341   public void setFieldValue(_Fields field, Object value) {
342     switch (field) {
343     case TABLE:
344       if (value == null) {
345         unsetTable();
346       } else {
347         setTable((ByteBuffer)value);
348       }
349       break;
350 
351     case ROW:
352       if (value == null) {
353         unsetRow();
354       } else {
355         setRow((ByteBuffer)value);
356       }
357       break;
358 
359     case COLUMNS:
360       if (value == null) {
361         unsetColumns();
362       } else {
363         setColumns((List<ByteBuffer>)value);
364       }
365       break;
366 
367     case VALUES:
368       if (value == null) {
369         unsetValues();
370       } else {
371         setValues((List<ByteBuffer>)value);
372       }
373       break;
374 
375     }
376   }
377 
378   public Object getFieldValue(_Fields field) {
379     switch (field) {
380     case TABLE:
381       return getTable();
382 
383     case ROW:
384       return getRow();
385 
386     case COLUMNS:
387       return getColumns();
388 
389     case VALUES:
390       return getValues();
391 
392     }
393     throw new IllegalStateException();
394   }
395 
396   /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
397   public boolean isSet(_Fields field) {
398     if (field == null) {
399       throw new IllegalArgumentException();
400     }
401 
402     switch (field) {
403     case TABLE:
404       return isSetTable();
405     case ROW:
406       return isSetRow();
407     case COLUMNS:
408       return isSetColumns();
409     case VALUES:
410       return isSetValues();
411     }
412     throw new IllegalStateException();
413   }
414 
415   @Override
416   public boolean equals(Object that) {
417     if (that == null)
418       return false;
419     if (that instanceof TAppend)
420       return this.equals((TAppend)that);
421     return false;
422   }
423 
424   public boolean equals(TAppend that) {
425     if (that == null)
426       return false;
427 
428     boolean this_present_table = true && this.isSetTable();
429     boolean that_present_table = true && that.isSetTable();
430     if (this_present_table || that_present_table) {
431       if (!(this_present_table && that_present_table))
432         return false;
433       if (!this.table.equals(that.table))
434         return false;
435     }
436 
437     boolean this_present_row = true && this.isSetRow();
438     boolean that_present_row = true && that.isSetRow();
439     if (this_present_row || that_present_row) {
440       if (!(this_present_row && that_present_row))
441         return false;
442       if (!this.row.equals(that.row))
443         return false;
444     }
445 
446     boolean this_present_columns = true && this.isSetColumns();
447     boolean that_present_columns = true && that.isSetColumns();
448     if (this_present_columns || that_present_columns) {
449       if (!(this_present_columns && that_present_columns))
450         return false;
451       if (!this.columns.equals(that.columns))
452         return false;
453     }
454 
455     boolean this_present_values = true && this.isSetValues();
456     boolean that_present_values = true && that.isSetValues();
457     if (this_present_values || that_present_values) {
458       if (!(this_present_values && that_present_values))
459         return false;
460       if (!this.values.equals(that.values))
461         return false;
462     }
463 
464     return true;
465   }
466 
467   @Override
468   public int hashCode() {
469     HashCodeBuilder builder = new HashCodeBuilder();
470 
471     boolean present_table = true && (isSetTable());
472     builder.append(present_table);
473     if (present_table)
474       builder.append(table);
475 
476     boolean present_row = true && (isSetRow());
477     builder.append(present_row);
478     if (present_row)
479       builder.append(row);
480 
481     boolean present_columns = true && (isSetColumns());
482     builder.append(present_columns);
483     if (present_columns)
484       builder.append(columns);
485 
486     boolean present_values = true && (isSetValues());
487     builder.append(present_values);
488     if (present_values)
489       builder.append(values);
490 
491     return builder.toHashCode();
492   }
493 
494   public int compareTo(TAppend other) {
495     if (!getClass().equals(other.getClass())) {
496       return getClass().getName().compareTo(other.getClass().getName());
497     }
498 
499     int lastComparison = 0;
500     TAppend typedOther = (TAppend)other;
501 
502     lastComparison = Boolean.valueOf(isSetTable()).compareTo(typedOther.isSetTable());
503     if (lastComparison != 0) {
504       return lastComparison;
505     }
506     if (isSetTable()) {
507       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.table, typedOther.table);
508       if (lastComparison != 0) {
509         return lastComparison;
510       }
511     }
512     lastComparison = Boolean.valueOf(isSetRow()).compareTo(typedOther.isSetRow());
513     if (lastComparison != 0) {
514       return lastComparison;
515     }
516     if (isSetRow()) {
517       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.row, typedOther.row);
518       if (lastComparison != 0) {
519         return lastComparison;
520       }
521     }
522     lastComparison = Boolean.valueOf(isSetColumns()).compareTo(typedOther.isSetColumns());
523     if (lastComparison != 0) {
524       return lastComparison;
525     }
526     if (isSetColumns()) {
527       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.columns, typedOther.columns);
528       if (lastComparison != 0) {
529         return lastComparison;
530       }
531     }
532     lastComparison = Boolean.valueOf(isSetValues()).compareTo(typedOther.isSetValues());
533     if (lastComparison != 0) {
534       return lastComparison;
535     }
536     if (isSetValues()) {
537       lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.values, typedOther.values);
538       if (lastComparison != 0) {
539         return lastComparison;
540       }
541     }
542     return 0;
543   }
544 
545   public _Fields fieldForId(int fieldId) {
546     return _Fields.findByThriftId(fieldId);
547   }
548 
549   public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
550     schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
551   }
552 
553   public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
554     schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
555   }
556 
557   @Override
558   public String toString() {
559     StringBuilder sb = new StringBuilder("TAppend(");
560     boolean first = true;
561 
562     sb.append("table:");
563     if (this.table == null) {
564       sb.append("null");
565     } else {
566       sb.append(this.table);
567     }
568     first = false;
569     if (!first) sb.append(", ");
570     sb.append("row:");
571     if (this.row == null) {
572       sb.append("null");
573     } else {
574       sb.append(this.row);
575     }
576     first = false;
577     if (!first) sb.append(", ");
578     sb.append("columns:");
579     if (this.columns == null) {
580       sb.append("null");
581     } else {
582       sb.append(this.columns);
583     }
584     first = false;
585     if (!first) sb.append(", ");
586     sb.append("values:");
587     if (this.values == null) {
588       sb.append("null");
589     } else {
590       sb.append(this.values);
591     }
592     first = false;
593     sb.append(")");
594     return sb.toString();
595   }
596 
597   public void validate() throws org.apache.thrift.TException {
598     // check for required fields
599     // check for sub-struct validity
600   }
601 
602   private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
603     try {
604       write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
605     } catch (org.apache.thrift.TException te) {
606       throw new java.io.IOException(te);
607     }
608   }
609 
610   private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
611     try {
612       read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
613     } catch (org.apache.thrift.TException te) {
614       throw new java.io.IOException(te);
615     }
616   }
617 
618   private static class TAppendStandardSchemeFactory implements SchemeFactory {
619     public TAppendStandardScheme getScheme() {
620       return new TAppendStandardScheme();
621     }
622   }
623 
624   private static class TAppendStandardScheme extends StandardScheme<TAppend> {
625 
626     public void read(org.apache.thrift.protocol.TProtocol iprot, TAppend struct) throws org.apache.thrift.TException {
627       org.apache.thrift.protocol.TField schemeField;
628       iprot.readStructBegin();
629       while (true)
630       {
631         schemeField = iprot.readFieldBegin();
632         if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
633           break;
634         }
635         switch (schemeField.id) {
636           case 1: // TABLE
637             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
638               struct.table = iprot.readBinary();
639               struct.setTableIsSet(true);
640             } else { 
641               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
642             }
643             break;
644           case 2: // ROW
645             if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
646               struct.row = iprot.readBinary();
647               struct.setRowIsSet(true);
648             } else { 
649               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
650             }
651             break;
652           case 3: // COLUMNS
653             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
654               {
655                 org.apache.thrift.protocol.TList _list34 = iprot.readListBegin();
656                 struct.columns = new ArrayList<ByteBuffer>(_list34.size);
657                 for (int _i35 = 0; _i35 < _list34.size; ++_i35)
658                 {
659                   ByteBuffer _elem36; // required
660                   _elem36 = iprot.readBinary();
661                   struct.columns.add(_elem36);
662                 }
663                 iprot.readListEnd();
664               }
665               struct.setColumnsIsSet(true);
666             } else { 
667               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
668             }
669             break;
670           case 4: // VALUES
671             if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
672               {
673                 org.apache.thrift.protocol.TList _list37 = iprot.readListBegin();
674                 struct.values = new ArrayList<ByteBuffer>(_list37.size);
675                 for (int _i38 = 0; _i38 < _list37.size; ++_i38)
676                 {
677                   ByteBuffer _elem39; // required
678                   _elem39 = iprot.readBinary();
679                   struct.values.add(_elem39);
680                 }
681                 iprot.readListEnd();
682               }
683               struct.setValuesIsSet(true);
684             } else { 
685               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
686             }
687             break;
688           default:
689             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
690         }
691         iprot.readFieldEnd();
692       }
693       iprot.readStructEnd();
694 
695       // check for required fields of primitive type, which can't be checked in the validate method
696       struct.validate();
697     }
698 
699     public void write(org.apache.thrift.protocol.TProtocol oprot, TAppend struct) throws org.apache.thrift.TException {
700       struct.validate();
701 
702       oprot.writeStructBegin(STRUCT_DESC);
703       if (struct.table != null) {
704         oprot.writeFieldBegin(TABLE_FIELD_DESC);
705         oprot.writeBinary(struct.table);
706         oprot.writeFieldEnd();
707       }
708       if (struct.row != null) {
709         oprot.writeFieldBegin(ROW_FIELD_DESC);
710         oprot.writeBinary(struct.row);
711         oprot.writeFieldEnd();
712       }
713       if (struct.columns != null) {
714         oprot.writeFieldBegin(COLUMNS_FIELD_DESC);
715         {
716           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.columns.size()));
717           for (ByteBuffer _iter40 : struct.columns)
718           {
719             oprot.writeBinary(_iter40);
720           }
721           oprot.writeListEnd();
722         }
723         oprot.writeFieldEnd();
724       }
725       if (struct.values != null) {
726         oprot.writeFieldBegin(VALUES_FIELD_DESC);
727         {
728           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.values.size()));
729           for (ByteBuffer _iter41 : struct.values)
730           {
731             oprot.writeBinary(_iter41);
732           }
733           oprot.writeListEnd();
734         }
735         oprot.writeFieldEnd();
736       }
737       oprot.writeFieldStop();
738       oprot.writeStructEnd();
739     }
740 
741   }
742 
743   private static class TAppendTupleSchemeFactory implements SchemeFactory {
744     public TAppendTupleScheme getScheme() {
745       return new TAppendTupleScheme();
746     }
747   }
748 
749   private static class TAppendTupleScheme extends TupleScheme<TAppend> {
750 
751     @Override
752     public void write(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
753       TTupleProtocol oprot = (TTupleProtocol) prot;
754       BitSet optionals = new BitSet();
755       if (struct.isSetTable()) {
756         optionals.set(0);
757       }
758       if (struct.isSetRow()) {
759         optionals.set(1);
760       }
761       if (struct.isSetColumns()) {
762         optionals.set(2);
763       }
764       if (struct.isSetValues()) {
765         optionals.set(3);
766       }
767       oprot.writeBitSet(optionals, 4);
768       if (struct.isSetTable()) {
769         oprot.writeBinary(struct.table);
770       }
771       if (struct.isSetRow()) {
772         oprot.writeBinary(struct.row);
773       }
774       if (struct.isSetColumns()) {
775         {
776           oprot.writeI32(struct.columns.size());
777           for (ByteBuffer _iter42 : struct.columns)
778           {
779             oprot.writeBinary(_iter42);
780           }
781         }
782       }
783       if (struct.isSetValues()) {
784         {
785           oprot.writeI32(struct.values.size());
786           for (ByteBuffer _iter43 : struct.values)
787           {
788             oprot.writeBinary(_iter43);
789           }
790         }
791       }
792     }
793 
794     @Override
795     public void read(org.apache.thrift.protocol.TProtocol prot, TAppend struct) throws org.apache.thrift.TException {
796       TTupleProtocol iprot = (TTupleProtocol) prot;
797       BitSet incoming = iprot.readBitSet(4);
798       if (incoming.get(0)) {
799         struct.table = iprot.readBinary();
800         struct.setTableIsSet(true);
801       }
802       if (incoming.get(1)) {
803         struct.row = iprot.readBinary();
804         struct.setRowIsSet(true);
805       }
806       if (incoming.get(2)) {
807         {
808           org.apache.thrift.protocol.TList _list44 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
809           struct.columns = new ArrayList<ByteBuffer>(_list44.size);
810           for (int _i45 = 0; _i45 < _list44.size; ++_i45)
811           {
812             ByteBuffer _elem46; // required
813             _elem46 = iprot.readBinary();
814             struct.columns.add(_elem46);
815           }
816         }
817         struct.setColumnsIsSet(true);
818       }
819       if (incoming.get(3)) {
820         {
821           org.apache.thrift.protocol.TList _list47 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
822           struct.values = new ArrayList<ByteBuffer>(_list47.size);
823           for (int _i48 = 0; _i48 < _list47.size; ++_i48)
824           {
825             ByteBuffer _elem49; // required
826             _elem49 = iprot.readBinary();
827             struct.values.add(_elem49);
828           }
829         }
830         struct.setValuesIsSet(true);
831       }
832     }
833   }
834 
835 }
836