/**
 * Autogenerated by Thrift Compiler (0.9.1)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.apache.avro.thrift.test;

import org.apache.thrift.scheme.IScheme;
import org.apache.thrift.scheme.SchemeFactory;
import org.apache.thrift.scheme.StandardScheme;

import org.apache.thrift.scheme.TupleScheme;
import org.apache.thrift.protocol.TTupleProtocol;
import org.apache.thrift.protocol.TProtocolException;
import org.apache.thrift.EncodingUtils;
import org.apache.thrift.TException;
import org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.server.AbstractNonblockingServer.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.EnumMap;
import java.util.Set;
import java.util.HashSet;
import java.util.EnumSet;
import java.util.Collections;
import java.util.BitSet;
import java.nio.ByteBuffer;
import java.util.Arrays;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Test implements org.apache.thrift.TBase<Test, Test._Fields>, java.io.Serializable, Cloneable, Comparable<Test> {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("Test");

  private static final org.apache.thrift.protocol.TField BOOL_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("boolField", org.apache.thrift.protocol.TType.BOOL, (short)1);
  private static final org.apache.thrift.protocol.TField BYTE_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("byteField", org.apache.thrift.protocol.TType.BYTE, (short)2);
  private static final org.apache.thrift.protocol.TField BYTE_OPTIONAL_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("byteOptionalField", org.apache.thrift.protocol.TType.BYTE, (short)16);
  private static final org.apache.thrift.protocol.TField I16_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("i16Field", org.apache.thrift.protocol.TType.I16, (short)3);
  private static final org.apache.thrift.protocol.TField I16_OPTIONAL_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("i16OptionalField", org.apache.thrift.protocol.TType.I16, (short)15);
  private static final org.apache.thrift.protocol.TField I32_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("i32Field", org.apache.thrift.protocol.TType.I32, (short)4);
  private static final org.apache.thrift.protocol.TField I64_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("i64Field", org.apache.thrift.protocol.TType.I64, (short)5);
  private static final org.apache.thrift.protocol.TField DOUBLE_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("doubleField", org.apache.thrift.protocol.TType.DOUBLE, (short)6);
  private static final org.apache.thrift.protocol.TField STRING_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("stringField", org.apache.thrift.protocol.TType.STRING, (short)7);
  private static final org.apache.thrift.protocol.TField BINARY_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("binaryField", org.apache.thrift.protocol.TType.STRING, (short)8);
  private static final org.apache.thrift.protocol.TField MAP_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("mapField", org.apache.thrift.protocol.TType.MAP, (short)9);
  private static final org.apache.thrift.protocol.TField LIST_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("listField", org.apache.thrift.protocol.TType.LIST, (short)10);
  private static final org.apache.thrift.protocol.TField SET_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("setField", org.apache.thrift.protocol.TType.SET, (short)11);
  private static final org.apache.thrift.protocol.TField ENUM_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("enumField", org.apache.thrift.protocol.TType.I32, (short)12);
  private static final org.apache.thrift.protocol.TField STRUCT_FIELD_FIELD_DESC = new org.apache.thrift.protocol.TField("structField", org.apache.thrift.protocol.TType.STRUCT, (short)13);
  private static final org.apache.thrift.protocol.TField FOO_OR_BAR_FIELD_DESC = new org.apache.thrift.protocol.TField("fooOrBar", org.apache.thrift.protocol.TType.STRUCT, (short)14);

  private static final Map<Class<? extends IScheme>, SchemeFactory> schemes = new HashMap<Class<? extends IScheme>, SchemeFactory>();
  static {
    schemes.put(StandardScheme.class, new TestStandardSchemeFactory());
    schemes.put(TupleScheme.class, new TestTupleSchemeFactory());
  }

  private boolean boolField; // required
  private byte byteField; // required
  private byte byteOptionalField; // optional
  private short i16Field; // required
  private short i16OptionalField; // optional
  private int i32Field; // optional
  private long i64Field; // required
  private double doubleField; // required
  private String stringField; // required
  private ByteBuffer binaryField; // optional
  private Map<String,Integer> mapField; // required
  private List<Integer> listField; // required
  private Set<Integer> setField; // required
  private E enumField; // required
  private Nested structField; // required
  private FooOrBar fooOrBar; // required

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
    BOOL_FIELD((short)1, "boolField"),
    BYTE_FIELD((short)2, "byteField"),
    BYTE_OPTIONAL_FIELD((short)16, "byteOptionalField"),
    I16_FIELD((short)3, "i16Field"),
    I16_OPTIONAL_FIELD((short)15, "i16OptionalField"),
    I32_FIELD((short)4, "i32Field"),
    I64_FIELD((short)5, "i64Field"),
    DOUBLE_FIELD((short)6, "doubleField"),
    STRING_FIELD((short)7, "stringField"),
    BINARY_FIELD((short)8, "binaryField"),
    MAP_FIELD((short)9, "mapField"),
    LIST_FIELD((short)10, "listField"),
    SET_FIELD((short)11, "setField"),
    /**
     *
     * @see E
     */
    ENUM_FIELD((short)12, "enumField"),
    STRUCT_FIELD((short)13, "structField"),
    FOO_OR_BAR((short)14, "fooOrBar");

    private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();

    static {
      for (_Fields field : EnumSet.allOf(_Fields.class)) {
        byName.put(field.getFieldName(), field);
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // BOOL_FIELD
          return BOOL_FIELD;
        case 2: // BYTE_FIELD
          return BYTE_FIELD;
        case 16: // BYTE_OPTIONAL_FIELD
          return BYTE_OPTIONAL_FIELD;
        case 3: // I16_FIELD
          return I16_FIELD;
        case 15: // I16_OPTIONAL_FIELD
          return I16_OPTIONAL_FIELD;
        case 4: // I32_FIELD
          return I32_FIELD;
        case 5: // I64_FIELD
          return I64_FIELD;
        case 6: // DOUBLE_FIELD
          return DOUBLE_FIELD;
        case 7: // STRING_FIELD
          return STRING_FIELD;
        case 8: // BINARY_FIELD
          return BINARY_FIELD;
        case 9: // MAP_FIELD
          return MAP_FIELD;
        case 10: // LIST_FIELD
          return LIST_FIELD;
        case 11: // SET_FIELD
          return SET_FIELD;
        case 12: // ENUM_FIELD
          return ENUM_FIELD;
        case 13: // STRUCT_FIELD
          return STRUCT_FIELD;
        case 14: // FOO_OR_BAR
          return FOO_OR_BAR;
        default:
          return null;
      }
    }

    /**
     * Find the _Fields constant that matches fieldId, throwing an exception
     * if it is not found.
     */
    public static _Fields findByThriftIdOrThrow(int fieldId) {
      _Fields fields = findByThriftId(fieldId);
      if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
      return fields;
    }

    /**
     * Find the _Fields constant that matches name, or null if its not found.
     */
    public static _Fields findByName(String name) {
      return byName.get(name);
    }

    private final short _thriftId;
    private final String _fieldName;

    _Fields(short thriftId, String fieldName) {
      _thriftId = thriftId;
      _fieldName = fieldName;
    }

    public short getThriftFieldId() {
      return _thriftId;
    }

    public String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  private static final int __BOOLFIELD_ISSET_ID = 0;
  private static final int __BYTEFIELD_ISSET_ID = 1;
  private static final int __BYTEOPTIONALFIELD_ISSET_ID = 2;
  private static final int __I16FIELD_ISSET_ID = 3;
  private static final int __I16OPTIONALFIELD_ISSET_ID = 4;
  private static final int __I32FIELD_ISSET_ID = 5;
  private static final int __I64FIELD_ISSET_ID = 6;
  private static final int __DOUBLEFIELD_ISSET_ID = 7;
  private byte __isset_bitfield = 0;
  private _Fields optionals[] = {_Fields.BYTE_OPTIONAL_FIELD,_Fields.I16_OPTIONAL_FIELD,_Fields.I32_FIELD,_Fields.BINARY_FIELD};
  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.BOOL_FIELD, new org.apache.thrift.meta_data.FieldMetaData("boolField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.BYTE_FIELD, new org.apache.thrift.meta_data.FieldMetaData("byteField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE)));
    tmpMap.put(_Fields.BYTE_OPTIONAL_FIELD, new org.apache.thrift.meta_data.FieldMetaData("byteOptionalField", org.apache.thrift.TFieldRequirementType.OPTIONAL,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BYTE)));
    tmpMap.put(_Fields.I16_FIELD, new org.apache.thrift.meta_data.FieldMetaData("i16Field", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16)));
    tmpMap.put(_Fields.I16_OPTIONAL_FIELD, new org.apache.thrift.meta_data.FieldMetaData("i16OptionalField", org.apache.thrift.TFieldRequirementType.OPTIONAL,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I16)));
    tmpMap.put(_Fields.I32_FIELD, new org.apache.thrift.meta_data.FieldMetaData("i32Field", org.apache.thrift.TFieldRequirementType.OPTIONAL,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    tmpMap.put(_Fields.I64_FIELD, new org.apache.thrift.meta_data.FieldMetaData("i64Field", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
    tmpMap.put(_Fields.DOUBLE_FIELD, new org.apache.thrift.meta_data.FieldMetaData("doubleField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
    tmpMap.put(_Fields.STRING_FIELD, new org.apache.thrift.meta_data.FieldMetaData("stringField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.BINARY_FIELD, new org.apache.thrift.meta_data.FieldMetaData("binaryField", org.apache.thrift.TFieldRequirementType.OPTIONAL,
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , true)));
    tmpMap.put(_Fields.MAP_FIELD, new org.apache.thrift.meta_data.FieldMetaData("mapField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.MapMetaData(org.apache.thrift.protocol.TType.MAP,
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING),
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))));
    tmpMap.put(_Fields.LIST_FIELD, new org.apache.thrift.meta_data.FieldMetaData("listField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))));
    tmpMap.put(_Fields.SET_FIELD, new org.apache.thrift.meta_data.FieldMetaData("setField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET,
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))));
    tmpMap.put(_Fields.ENUM_FIELD, new org.apache.thrift.meta_data.FieldMetaData("enumField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.EnumMetaData(org.apache.thrift.protocol.TType.ENUM, E.class)));
    tmpMap.put(_Fields.STRUCT_FIELD, new org.apache.thrift.meta_data.FieldMetaData("structField", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Nested.class)));
    tmpMap.put(_Fields.FOO_OR_BAR, new org.apache.thrift.meta_data.FieldMetaData("fooOrBar", org.apache.thrift.TFieldRequirementType.DEFAULT,
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, FooOrBar.class)));
    metaDataMap = Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(Test.class, metaDataMap);
  }

  public Test() {
  }

  public Test(
    boolean boolField,
    byte byteField,
    short i16Field,
    long i64Field,
    double doubleField,
    String stringField,
    Map<String,Integer> mapField,
    List<Integer> listField,
    Set<Integer> setField,
    E enumField,
    Nested structField,
    FooOrBar fooOrBar)
  {
    this();
    this.boolField = boolField;
    setBoolFieldIsSet(true);
    this.byteField = byteField;
    setByteFieldIsSet(true);
    this.i16Field = i16Field;
    setI16FieldIsSet(true);
    this.i64Field = i64Field;
    setI64FieldIsSet(true);
    this.doubleField = doubleField;
    setDoubleFieldIsSet(true);
    this.stringField = stringField;
    this.mapField = mapField;
    this.listField = listField;
    this.setField = setField;
    this.enumField = enumField;
    this.structField = structField;
    this.fooOrBar = fooOrBar;
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public Test(Test other) {
    __isset_bitfield = other.__isset_bitfield;
    this.boolField = other.boolField;
    this.byteField = other.byteField;
    this.byteOptionalField = other.byteOptionalField;
    this.i16Field = other.i16Field;
    this.i16OptionalField = other.i16OptionalField;
    this.i32Field = other.i32Field;
    this.i64Field = other.i64Field;
    this.doubleField = other.doubleField;
    if (other.isSetStringField()) {
      this.stringField = other.stringField;
    }
    if (other.isSetBinaryField()) {
      this.binaryField = org.apache.thrift.TBaseHelper.copyBinary(other.binaryField);
;
    }
    if (other.isSetMapField()) {
      Map<String,Integer> __this__mapField = new HashMap<String,Integer>(other.mapField);
      this.mapField = __this__mapField;
    }
    if (other.isSetListField()) {
      List<Integer> __this__listField = new ArrayList<Integer>(other.listField);
      this.listField = __this__listField;
    }
    if (other.isSetSetField()) {
      Set<Integer> __this__setField = new HashSet<Integer>(other.setField);
      this.setField = __this__setField;
    }
    if (other.isSetEnumField()) {
      this.enumField = other.enumField;
    }
    if (other.isSetStructField()) {
      this.structField = new Nested(other.structField);
    }
    if (other.isSetFooOrBar()) {
      this.fooOrBar = new FooOrBar(other.fooOrBar);
    }
  }

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

  @Override
  public void clear() {
    setBoolFieldIsSet(false);
    this.boolField = false;
    setByteFieldIsSet(false);
    this.byteField = 0;
    setByteOptionalFieldIsSet(false);
    this.byteOptionalField = 0;
    setI16FieldIsSet(false);
    this.i16Field = 0;
    setI16OptionalFieldIsSet(false);
    this.i16OptionalField = 0;
    setI32FieldIsSet(false);
    this.i32Field = 0;
    setI64FieldIsSet(false);
    this.i64Field = 0;
    setDoubleFieldIsSet(false);
    this.doubleField = 0.0;
    this.stringField = null;
    this.binaryField = null;
    this.mapField = null;
    this.listField = null;
    this.setField = null;
    this.enumField = null;
    this.structField = null;
    this.fooOrBar = null;
  }

  public boolean isBoolField() {
    return this.boolField;
  }

  public void setBoolField(boolean boolField) {
    this.boolField = boolField;
    setBoolFieldIsSet(true);
  }

  public void unsetBoolField() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BOOLFIELD_ISSET_ID);
  }

  /** Returns true if field boolField is set (has been assigned a value) and false otherwise */
  public boolean isSetBoolField() {
    return EncodingUtils.testBit(__isset_bitfield, __BOOLFIELD_ISSET_ID);
  }

  public void setBoolFieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BOOLFIELD_ISSET_ID, value);
  }

  public byte getByteField() {
    return this.byteField;
  }

  public void setByteField(byte byteField) {
    this.byteField = byteField;
    setByteFieldIsSet(true);
  }

  public void unsetByteField() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BYTEFIELD_ISSET_ID);
  }

  /** Returns true if field byteField is set (has been assigned a value) and false otherwise */
  public boolean isSetByteField() {
    return EncodingUtils.testBit(__isset_bitfield, __BYTEFIELD_ISSET_ID);
  }

  public void setByteFieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BYTEFIELD_ISSET_ID, value);
  }

  public byte getByteOptionalField() {
    return this.byteOptionalField;
  }

  public void setByteOptionalField(byte byteOptionalField) {
    this.byteOptionalField = byteOptionalField;
    setByteOptionalFieldIsSet(true);
  }

  public void unsetByteOptionalField() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __BYTEOPTIONALFIELD_ISSET_ID);
  }

  /** Returns true if field byteOptionalField is set (has been assigned a value) and false otherwise */
  public boolean isSetByteOptionalField() {
    return EncodingUtils.testBit(__isset_bitfield, __BYTEOPTIONALFIELD_ISSET_ID);
  }

  public void setByteOptionalFieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __BYTEOPTIONALFIELD_ISSET_ID, value);
  }

  public short getI16Field() {
    return this.i16Field;
  }

  public void setI16Field(short i16Field) {
    this.i16Field = i16Field;
    setI16FieldIsSet(true);
  }

  public void unsetI16Field() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __I16FIELD_ISSET_ID);
  }

  /** Returns true if field i16Field is set (has been assigned a value) and false otherwise */
  public boolean isSetI16Field() {
    return EncodingUtils.testBit(__isset_bitfield, __I16FIELD_ISSET_ID);
  }

  public void setI16FieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __I16FIELD_ISSET_ID, value);
  }

  public short getI16OptionalField() {
    return this.i16OptionalField;
  }

  public void setI16OptionalField(short i16OptionalField) {
    this.i16OptionalField = i16OptionalField;
    setI16OptionalFieldIsSet(true);
  }

  public void unsetI16OptionalField() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __I16OPTIONALFIELD_ISSET_ID);
  }

  /** Returns true if field i16OptionalField is set (has been assigned a value) and false otherwise */
  public boolean isSetI16OptionalField() {
    return EncodingUtils.testBit(__isset_bitfield, __I16OPTIONALFIELD_ISSET_ID);
  }

  public void setI16OptionalFieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __I16OPTIONALFIELD_ISSET_ID, value);
  }

  public int getI32Field() {
    return this.i32Field;
  }

  public void setI32Field(int i32Field) {
    this.i32Field = i32Field;
    setI32FieldIsSet(true);
  }

  public void unsetI32Field() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __I32FIELD_ISSET_ID);
  }

  /** Returns true if field i32Field is set (has been assigned a value) and false otherwise */
  public boolean isSetI32Field() {
    return EncodingUtils.testBit(__isset_bitfield, __I32FIELD_ISSET_ID);
  }

  public void setI32FieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __I32FIELD_ISSET_ID, value);
  }

  public long getI64Field() {
    return this.i64Field;
  }

  public void setI64Field(long i64Field) {
    this.i64Field = i64Field;
    setI64FieldIsSet(true);
  }

  public void unsetI64Field() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __I64FIELD_ISSET_ID);
  }

  /** Returns true if field i64Field is set (has been assigned a value) and false otherwise */
  public boolean isSetI64Field() {
    return EncodingUtils.testBit(__isset_bitfield, __I64FIELD_ISSET_ID);
  }

  public void setI64FieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __I64FIELD_ISSET_ID, value);
  }

  public double getDoubleField() {
    return this.doubleField;
  }

  public void setDoubleField(double doubleField) {
    this.doubleField = doubleField;
    setDoubleFieldIsSet(true);
  }

  public void unsetDoubleField() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __DOUBLEFIELD_ISSET_ID);
  }

  /** Returns true if field doubleField is set (has been assigned a value) and false otherwise */
  public boolean isSetDoubleField() {
    return EncodingUtils.testBit(__isset_bitfield, __DOUBLEFIELD_ISSET_ID);
  }

  public void setDoubleFieldIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __DOUBLEFIELD_ISSET_ID, value);
  }

  public String getStringField() {
    return this.stringField;
  }

  public void setStringField(String stringField) {
    this.stringField = stringField;
  }

  public void unsetStringField() {
    this.stringField = null;
  }

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

  public void setStringFieldIsSet(boolean value) {
    if (!value) {
      this.stringField = null;
    }
  }

  public byte[] getBinaryField() {
    setBinaryField(org.apache.thrift.TBaseHelper.rightSize(binaryField));
    return binaryField == null ? null : binaryField.array();
  }

  public ByteBuffer bufferForBinaryField() {
    return binaryField;
  }

  public void setBinaryField(byte[] binaryField) {
    setBinaryField(binaryField == null ? (ByteBuffer)null : ByteBuffer.wrap(binaryField));
  }

  public void setBinaryField(ByteBuffer binaryField) {
    this.binaryField = binaryField;
  }

  public void unsetBinaryField() {
    this.binaryField = null;
  }

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

  public void setBinaryFieldIsSet(boolean value) {
    if (!value) {
      this.binaryField = null;
    }
  }

  public int getMapFieldSize() {
    return (this.mapField == null) ? 0 : this.mapField.size();
  }

  public void putToMapField(String key, int val) {
    if (this.mapField == null) {
      this.mapField = new HashMap<String,Integer>();
    }
    this.mapField.put(key, val);
  }

  public Map<String,Integer> getMapField() {
    return this.mapField;
  }

  public void setMapField(Map<String,Integer> mapField) {
    this.mapField = mapField;
  }

  public void unsetMapField() {
    this.mapField = null;
  }

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

  public void setMapFieldIsSet(boolean value) {
    if (!value) {
      this.mapField = null;
    }
  }

  public int getListFieldSize() {
    return (this.listField == null) ? 0 : this.listField.size();
  }

  public java.util.Iterator<Integer> getListFieldIterator() {
    return (this.listField == null) ? null : this.listField.iterator();
  }

  public void addToListField(int elem) {
    if (this.listField == null) {
      this.listField = new ArrayList<Integer>();
    }
    this.listField.add(elem);
  }

  public List<Integer> getListField() {
    return this.listField;
  }

  public void setListField(List<Integer> listField) {
    this.listField = listField;
  }

  public void unsetListField() {
    this.listField = null;
  }

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

  public void setListFieldIsSet(boolean value) {
    if (!value) {
      this.listField = null;
    }
  }

  public int getSetFieldSize() {
    return (this.setField == null) ? 0 : this.setField.size();
  }

  public java.util.Iterator<Integer> getSetFieldIterator() {
    return (this.setField == null) ? null : this.setField.iterator();
  }

  public void addToSetField(int elem) {
    if (this.setField == null) {
      this.setField = new HashSet<Integer>();
    }
    this.setField.add(elem);
  }

  public Set<Integer> getSetField() {
    return this.setField;
  }

  public void setSetField(Set<Integer> setField) {
    this.setField = setField;
  }

  public void unsetSetField() {
    this.setField = null;
  }

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

  public void setSetFieldIsSet(boolean value) {
    if (!value) {
      this.setField = null;
    }
  }

  /**
   *
   * @see E
   */
  public E getEnumField() {
    return this.enumField;
  }

  /**
   *
   * @see E
   */
  public void setEnumField(E enumField) {
    this.enumField = enumField;
  }

  public void unsetEnumField() {
    this.enumField = null;
  }

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

  public void setEnumFieldIsSet(boolean value) {
    if (!value) {
      this.enumField = null;
    }
  }

  public Nested getStructField() {
    return this.structField;
  }

  public void setStructField(Nested structField) {
    this.structField = structField;
  }

  public void unsetStructField() {
    this.structField = null;
  }

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

  public void setStructFieldIsSet(boolean value) {
    if (!value) {
      this.structField = null;
    }
  }

  public FooOrBar getFooOrBar() {
    return this.fooOrBar;
  }

  public void setFooOrBar(FooOrBar fooOrBar) {
    this.fooOrBar = fooOrBar;
  }

  public void unsetFooOrBar() {
    this.fooOrBar = null;
  }

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

  public void setFooOrBarIsSet(boolean value) {
    if (!value) {
      this.fooOrBar = null;
    }
  }

  public void setFieldValue(_Fields field, Object value) {
    switch (field) {
    case BOOL_FIELD:
      if (value == null) {
        unsetBoolField();
      } else {
        setBoolField((Boolean)value);
      }
      break;

    case BYTE_FIELD:
      if (value == null) {
        unsetByteField();
      } else {
        setByteField((Byte)value);
      }
      break;

    case BYTE_OPTIONAL_FIELD:
      if (value == null) {
        unsetByteOptionalField();
      } else {
        setByteOptionalField((Byte)value);
      }
      break;

    case I16_FIELD:
      if (value == null) {
        unsetI16Field();
      } else {
        setI16Field((Short)value);
      }
      break;

    case I16_OPTIONAL_FIELD:
      if (value == null) {
        unsetI16OptionalField();
      } else {
        setI16OptionalField((Short)value);
      }
      break;

    case I32_FIELD:
      if (value == null) {
        unsetI32Field();
      } else {
        setI32Field((Integer)value);
      }
      break;

    case I64_FIELD:
      if (value == null) {
        unsetI64Field();
      } else {
        setI64Field((Long)value);
      }
      break;

    case DOUBLE_FIELD:
      if (value == null) {
        unsetDoubleField();
      } else {
        setDoubleField((Double)value);
      }
      break;

    case STRING_FIELD:
      if (value == null) {
        unsetStringField();
      } else {
        setStringField((String)value);
      }
      break;

    case BINARY_FIELD:
      if (value == null) {
        unsetBinaryField();
      } else {
        setBinaryField((ByteBuffer)value);
      }
      break;

    case MAP_FIELD:
      if (value == null) {
        unsetMapField();
      } else {
        setMapField((Map<String,Integer>)value);
      }
      break;

    case LIST_FIELD:
      if (value == null) {
        unsetListField();
      } else {
        setListField((List<Integer>)value);
      }
      break;

    case SET_FIELD:
      if (value == null) {
        unsetSetField();
      } else {
        setSetField((Set<Integer>)value);
      }
      break;

    case ENUM_FIELD:
      if (value == null) {
        unsetEnumField();
      } else {
        setEnumField((E)value);
      }
      break;

    case STRUCT_FIELD:
      if (value == null) {
        unsetStructField();
      } else {
        setStructField((Nested)value);
      }
      break;

    case FOO_OR_BAR:
      if (value == null) {
        unsetFooOrBar();
      } else {
        setFooOrBar((FooOrBar)value);
      }
      break;

    }
  }

  public Object getFieldValue(_Fields field) {
    switch (field) {
    case BOOL_FIELD:
      return Boolean.valueOf(isBoolField());

    case BYTE_FIELD:
      return Byte.valueOf(getByteField());

    case BYTE_OPTIONAL_FIELD:
      return Byte.valueOf(getByteOptionalField());

    case I16_FIELD:
      return Short.valueOf(getI16Field());

    case I16_OPTIONAL_FIELD:
      return Short.valueOf(getI16OptionalField());

    case I32_FIELD:
      return Integer.valueOf(getI32Field());

    case I64_FIELD:
      return Long.valueOf(getI64Field());

    case DOUBLE_FIELD:
      return Double.valueOf(getDoubleField());

    case STRING_FIELD:
      return getStringField();

    case BINARY_FIELD:
      return getBinaryField();

    case MAP_FIELD:
      return getMapField();

    case LIST_FIELD:
      return getListField();

    case SET_FIELD:
      return getSetField();

    case ENUM_FIELD:
      return getEnumField();

    case STRUCT_FIELD:
      return getStructField();

    case FOO_OR_BAR:
      return getFooOrBar();

    }
    throw new IllegalStateException();
  }

  /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
  public boolean isSet(_Fields field) {
    if (field == null) {
      throw new IllegalArgumentException();
    }

    switch (field) {
    case BOOL_FIELD:
      return isSetBoolField();
    case BYTE_FIELD:
      return isSetByteField();
    case BYTE_OPTIONAL_FIELD:
      return isSetByteOptionalField();
    case I16_FIELD:
      return isSetI16Field();
    case I16_OPTIONAL_FIELD:
      return isSetI16OptionalField();
    case I32_FIELD:
      return isSetI32Field();
    case I64_FIELD:
      return isSetI64Field();
    case DOUBLE_FIELD:
      return isSetDoubleField();
    case STRING_FIELD:
      return isSetStringField();
    case BINARY_FIELD:
      return isSetBinaryField();
    case MAP_FIELD:
      return isSetMapField();
    case LIST_FIELD:
      return isSetListField();
    case SET_FIELD:
      return isSetSetField();
    case ENUM_FIELD:
      return isSetEnumField();
    case STRUCT_FIELD:
      return isSetStructField();
    case FOO_OR_BAR:
      return isSetFooOrBar();
    }
    throw new IllegalStateException();
  }

  @Override
  public boolean equals(Object that) {
    if (that == null)
      return false;
    if (that instanceof Test)
      return this.equals((Test)that);
    return false;
  }

  public boolean equals(Test that) {
    if (that == null)
      return false;

    boolean this_present_boolField = true;
    boolean that_present_boolField = true;
    if (this_present_boolField || that_present_boolField) {
      if (!(this_present_boolField && that_present_boolField))
        return false;
      if (this.boolField != that.boolField)
        return false;
    }

    boolean this_present_byteField = true;
    boolean that_present_byteField = true;
    if (this_present_byteField || that_present_byteField) {
      if (!(this_present_byteField && that_present_byteField))
        return false;
      if (this.byteField != that.byteField)
        return false;
    }

    boolean this_present_byteOptionalField = true && this.isSetByteOptionalField();
    boolean that_present_byteOptionalField = true && that.isSetByteOptionalField();
    if (this_present_byteOptionalField || that_present_byteOptionalField) {
      if (!(this_present_byteOptionalField && that_present_byteOptionalField))
        return false;
      if (this.byteOptionalField != that.byteOptionalField)
        return false;
    }

    boolean this_present_i16Field = true;
    boolean that_present_i16Field = true;
    if (this_present_i16Field || that_present_i16Field) {
      if (!(this_present_i16Field && that_present_i16Field))
        return false;
      if (this.i16Field != that.i16Field)
        return false;
    }

    boolean this_present_i16OptionalField = true && this.isSetI16OptionalField();
    boolean that_present_i16OptionalField = true && that.isSetI16OptionalField();
    if (this_present_i16OptionalField || that_present_i16OptionalField) {
      if (!(this_present_i16OptionalField && that_present_i16OptionalField))
        return false;
      if (this.i16OptionalField != that.i16OptionalField)
        return false;
    }

    boolean this_present_i32Field = true && this.isSetI32Field();
    boolean that_present_i32Field = true && that.isSetI32Field();
    if (this_present_i32Field || that_present_i32Field) {
      if (!(this_present_i32Field && that_present_i32Field))
        return false;
      if (this.i32Field != that.i32Field)
        return false;
    }

    boolean this_present_i64Field = true;
    boolean that_present_i64Field = true;
    if (this_present_i64Field || that_present_i64Field) {
      if (!(this_present_i64Field && that_present_i64Field))
        return false;
      if (this.i64Field != that.i64Field)
        return false;
    }

    boolean this_present_doubleField = true;
    boolean that_present_doubleField = true;
    if (this_present_doubleField || that_present_doubleField) {
      if (!(this_present_doubleField && that_present_doubleField))
        return false;
      if (this.doubleField != that.doubleField)
        return false;
    }

    boolean this_present_stringField = true && this.isSetStringField();
    boolean that_present_stringField = true && that.isSetStringField();
    if (this_present_stringField || that_present_stringField) {
      if (!(this_present_stringField && that_present_stringField))
        return false;
      if (!this.stringField.equals(that.stringField))
        return false;
    }

    boolean this_present_binaryField = true && this.isSetBinaryField();
    boolean that_present_binaryField = true && that.isSetBinaryField();
    if (this_present_binaryField || that_present_binaryField) {
      if (!(this_present_binaryField && that_present_binaryField))
        return false;
      if (!this.binaryField.equals(that.binaryField))
        return false;
    }

    boolean this_present_mapField = true && this.isSetMapField();
    boolean that_present_mapField = true && that.isSetMapField();
    if (this_present_mapField || that_present_mapField) {
      if (!(this_present_mapField && that_present_mapField))
        return false;
      if (!this.mapField.equals(that.mapField))
        return false;
    }

    boolean this_present_listField = true && this.isSetListField();
    boolean that_present_listField = true && that.isSetListField();
    if (this_present_listField || that_present_listField) {
      if (!(this_present_listField && that_present_listField))
        return false;
      if (!this.listField.equals(that.listField))
        return false;
    }

    boolean this_present_setField = true && this.isSetSetField();
    boolean that_present_setField = true && that.isSetSetField();
    if (this_present_setField || that_present_setField) {
      if (!(this_present_setField && that_present_setField))
        return false;
      if (!this.setField.equals(that.setField))
        return false;
    }

    boolean this_present_enumField = true && this.isSetEnumField();
    boolean that_present_enumField = true && that.isSetEnumField();
    if (this_present_enumField || that_present_enumField) {
      if (!(this_present_enumField && that_present_enumField))
        return false;
      if (!this.enumField.equals(that.enumField))
        return false;
    }

    boolean this_present_structField = true && this.isSetStructField();
    boolean that_present_structField = true && that.isSetStructField();
    if (this_present_structField || that_present_structField) {
      if (!(this_present_structField && that_present_structField))
        return false;
      if (!this.structField.equals(that.structField))
        return false;
    }

    boolean this_present_fooOrBar = true && this.isSetFooOrBar();
    boolean that_present_fooOrBar = true && that.isSetFooOrBar();
    if (this_present_fooOrBar || that_present_fooOrBar) {
      if (!(this_present_fooOrBar && that_present_fooOrBar))
        return false;
      if (!this.fooOrBar.equals(that.fooOrBar))
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    return 0;
  }

  @Override
  public int compareTo(Test other) {
    if (!getClass().equals(other.getClass())) {
      return getClass().getName().compareTo(other.getClass().getName());
    }

    int lastComparison = 0;

    lastComparison = Boolean.valueOf(isSetBoolField()).compareTo(other.isSetBoolField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetBoolField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.boolField, other.boolField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetByteField()).compareTo(other.isSetByteField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetByteField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.byteField, other.byteField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetByteOptionalField()).compareTo(other.isSetByteOptionalField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetByteOptionalField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.byteOptionalField, other.byteOptionalField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetI16Field()).compareTo(other.isSetI16Field());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetI16Field()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.i16Field, other.i16Field);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetI16OptionalField()).compareTo(other.isSetI16OptionalField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetI16OptionalField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.i16OptionalField, other.i16OptionalField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetI32Field()).compareTo(other.isSetI32Field());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetI32Field()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.i32Field, other.i32Field);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetI64Field()).compareTo(other.isSetI64Field());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetI64Field()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.i64Field, other.i64Field);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetDoubleField()).compareTo(other.isSetDoubleField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetDoubleField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.doubleField, other.doubleField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetStringField()).compareTo(other.isSetStringField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetStringField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.stringField, other.stringField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetBinaryField()).compareTo(other.isSetBinaryField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetBinaryField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.binaryField, other.binaryField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetMapField()).compareTo(other.isSetMapField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetMapField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.mapField, other.mapField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetListField()).compareTo(other.isSetListField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetListField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.listField, other.listField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetSetField()).compareTo(other.isSetSetField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetSetField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.setField, other.setField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetEnumField()).compareTo(other.isSetEnumField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetEnumField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.enumField, other.enumField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetStructField()).compareTo(other.isSetStructField());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetStructField()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.structField, other.structField);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetFooOrBar()).compareTo(other.isSetFooOrBar());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetFooOrBar()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fooOrBar, other.fooOrBar);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

  public _Fields fieldForId(int fieldId) {
    return _Fields.findByThriftId(fieldId);
  }

  public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
    schemes.get(iprot.getScheme()).getScheme().read(iprot, this);
  }

  public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
    schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("Test(");
    boolean first = true;

    sb.append("boolField:");
    sb.append(this.boolField);
    first = false;
    if (!first) sb.append(", ");
    sb.append("byteField:");
    sb.append(this.byteField);
    first = false;
    if (isSetByteOptionalField()) {
      if (!first) sb.append(", ");
      sb.append("byteOptionalField:");
      sb.append(this.byteOptionalField);
      first = false;
    }
    if (!first) sb.append(", ");
    sb.append("i16Field:");
    sb.append(this.i16Field);
    first = false;
    if (isSetI16OptionalField()) {
      if (!first) sb.append(", ");
      sb.append("i16OptionalField:");
      sb.append(this.i16OptionalField);
      first = false;
    }
    if (isSetI32Field()) {
      if (!first) sb.append(", ");
      sb.append("i32Field:");
      sb.append(this.i32Field);
      first = false;
    }
    if (!first) sb.append(", ");
    sb.append("i64Field:");
    sb.append(this.i64Field);
    first = false;
    if (!first) sb.append(", ");
    sb.append("doubleField:");
    sb.append(this.doubleField);
    first = false;
    if (!first) sb.append(", ");
    sb.append("stringField:");
    if (this.stringField == null) {
      sb.append("null");
    } else {
      sb.append(this.stringField);
    }
    first = false;
    if (isSetBinaryField()) {
      if (!first) sb.append(", ");
      sb.append("binaryField:");
      if (this.binaryField == null) {
        sb.append("null");
      } else {
        org.apache.thrift.TBaseHelper.toString(this.binaryField, sb);
      }
      first = false;
    }
    if (!first) sb.append(", ");
    sb.append("mapField:");
    if (this.mapField == null) {
      sb.append("null");
    } else {
      sb.append(this.mapField);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("listField:");
    if (this.listField == null) {
      sb.append("null");
    } else {
      sb.append(this.listField);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("setField:");
    if (this.setField == null) {
      sb.append("null");
    } else {
      sb.append(this.setField);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("enumField:");
    if (this.enumField == null) {
      sb.append("null");
    } else {
      sb.append(this.enumField);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("structField:");
    if (this.structField == null) {
      sb.append("null");
    } else {
      sb.append(this.structField);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("fooOrBar:");
    if (this.fooOrBar == null) {
      sb.append("null");
    } else {
      sb.append(this.fooOrBar);
    }
    first = false;
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws org.apache.thrift.TException {
    // check for required fields
    // check for sub-struct validity
    if (structField != null) {
      structField.validate();
    }
  }

  private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
    try {
      write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
    try {
      // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
      __isset_bitfield = 0;
      read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
    } catch (org.apache.thrift.TException te) {
      throw new java.io.IOException(te);
    }
  }

  private static class TestStandardSchemeFactory implements SchemeFactory {
    public TestStandardScheme getScheme() {
      return new TestStandardScheme();
    }
  }

  private static class TestStandardScheme extends StandardScheme<Test> {

    public void read(org.apache.thrift.protocol.TProtocol iprot, Test struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TField schemeField;
      iprot.readStructBegin();
      while (true)
      {
        schemeField = iprot.readFieldBegin();
        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
          break;
        }
        switch (schemeField.id) {
          case 1: // BOOL_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.boolField = iprot.readBool();
              struct.setBoolFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 2: // BYTE_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) {
              struct.byteField = iprot.readByte();
              struct.setByteFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 16: // BYTE_OPTIONAL_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.BYTE) {
              struct.byteOptionalField = iprot.readByte();
              struct.setByteOptionalFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 3: // I16_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.I16) {
              struct.i16Field = iprot.readI16();
              struct.setI16FieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 15: // I16_OPTIONAL_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.I16) {
              struct.i16OptionalField = iprot.readI16();
              struct.setI16OptionalFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 4: // I32_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.i32Field = iprot.readI32();
              struct.setI32FieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 5: // I64_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.i64Field = iprot.readI64();
              struct.setI64FieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 6: // DOUBLE_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.DOUBLE) {
              struct.doubleField = iprot.readDouble();
              struct.setDoubleFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 7: // STRING_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.stringField = iprot.readString();
              struct.setStringFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 8: // BINARY_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.binaryField = iprot.readBinary();
              struct.setBinaryFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 9: // MAP_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.MAP) {
              {
                org.apache.thrift.protocol.TMap _map0 = iprot.readMapBegin();
                struct.mapField = new HashMap<String,Integer>(2*_map0.size);
                for (int _i1 = 0; _i1 < _map0.size; ++_i1)
                {
                  String _key2;
                  int _val3;
                  _key2 = iprot.readString();
                  _val3 = iprot.readI32();
                  struct.mapField.put(_key2, _val3);
                }
                iprot.readMapEnd();
              }
              struct.setMapFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 10: // LIST_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list4 = iprot.readListBegin();
                struct.listField = new ArrayList<Integer>(_list4.size);
                for (int _i5 = 0; _i5 < _list4.size; ++_i5)
                {
                  int _elem6;
                  _elem6 = iprot.readI32();
                  struct.listField.add(_elem6);
                }
                iprot.readListEnd();
              }
              struct.setListFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 11: // SET_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
              {
                org.apache.thrift.protocol.TSet _set7 = iprot.readSetBegin();
                struct.setField = new HashSet<Integer>(2*_set7.size);
                for (int _i8 = 0; _i8 < _set7.size; ++_i8)
                {
                  int _elem9;
                  _elem9 = iprot.readI32();
                  struct.setField.add(_elem9);
                }
                iprot.readSetEnd();
              }
              struct.setSetFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 12: // ENUM_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.enumField = E.findByValue(iprot.readI32());
              struct.setEnumFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 13: // STRUCT_FIELD
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.structField = new Nested();
              struct.structField.read(iprot);
              struct.setStructFieldIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 14: // FOO_OR_BAR
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.fooOrBar = new FooOrBar();
              struct.fooOrBar.read(iprot);
              struct.setFooOrBarIsSet(true);
            } else {
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          default:
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();
      struct.validate();
    }

    public void write(org.apache.thrift.protocol.TProtocol oprot, Test struct) throws org.apache.thrift.TException {
      struct.validate();

      oprot.writeStructBegin(STRUCT_DESC);
      oprot.writeFieldBegin(BOOL_FIELD_FIELD_DESC);
      oprot.writeBool(struct.boolField);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(BYTE_FIELD_FIELD_DESC);
      oprot.writeByte(struct.byteField);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(I16_FIELD_FIELD_DESC);
      oprot.writeI16(struct.i16Field);
      oprot.writeFieldEnd();
      if (struct.isSetI32Field()) {
        oprot.writeFieldBegin(I32_FIELD_FIELD_DESC);
        oprot.writeI32(struct.i32Field);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(I64_FIELD_FIELD_DESC);
      oprot.writeI64(struct.i64Field);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(DOUBLE_FIELD_FIELD_DESC);
      oprot.writeDouble(struct.doubleField);
      oprot.writeFieldEnd();
      if (struct.stringField != null) {
        oprot.writeFieldBegin(STRING_FIELD_FIELD_DESC);
        oprot.writeString(struct.stringField);
        oprot.writeFieldEnd();
      }
      if (struct.binaryField != null) {
        if (struct.isSetBinaryField()) {
          oprot.writeFieldBegin(BINARY_FIELD_FIELD_DESC);
          oprot.writeBinary(struct.binaryField);
          oprot.writeFieldEnd();
        }
      }
      if (struct.mapField != null) {
        oprot.writeFieldBegin(MAP_FIELD_FIELD_DESC);
        {
          oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, struct.mapField.size()));
          for (Map.Entry<String, Integer> _iter10 : struct.mapField.entrySet())
          {
            oprot.writeString(_iter10.getKey());
            oprot.writeI32(_iter10.getValue());
          }
          oprot.writeMapEnd();
        }
        oprot.writeFieldEnd();
      }
      if (struct.listField != null) {
        oprot.writeFieldBegin(LIST_FIELD_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.listField.size()));
          for (int _iter11 : struct.listField)
          {
            oprot.writeI32(_iter11);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (struct.setField != null) {
        oprot.writeFieldBegin(SET_FIELD_FIELD_DESC);
        {
          oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, struct.setField.size()));
          for (int _iter12 : struct.setField)
          {
            oprot.writeI32(_iter12);
          }
          oprot.writeSetEnd();
        }
        oprot.writeFieldEnd();
      }
      if (struct.enumField != null) {
        oprot.writeFieldBegin(ENUM_FIELD_FIELD_DESC);
        oprot.writeI32(struct.enumField.getValue());
        oprot.writeFieldEnd();
      }
      if (struct.structField != null) {
        oprot.writeFieldBegin(STRUCT_FIELD_FIELD_DESC);
        struct.structField.write(oprot);
        oprot.writeFieldEnd();
      }
      if (struct.fooOrBar != null) {
        oprot.writeFieldBegin(FOO_OR_BAR_FIELD_DESC);
        struct.fooOrBar.write(oprot);
        oprot.writeFieldEnd();
      }
      if (struct.isSetI16OptionalField()) {
        oprot.writeFieldBegin(I16_OPTIONAL_FIELD_FIELD_DESC);
        oprot.writeI16(struct.i16OptionalField);
        oprot.writeFieldEnd();
      }
      if (struct.isSetByteOptionalField()) {
        oprot.writeFieldBegin(BYTE_OPTIONAL_FIELD_FIELD_DESC);
        oprot.writeByte(struct.byteOptionalField);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class TestTupleSchemeFactory implements SchemeFactory {
    public TestTupleScheme getScheme() {
      return new TestTupleScheme();
    }
  }

  private static class TestTupleScheme extends TupleScheme<Test> {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, Test struct) throws org.apache.thrift.TException {
      TTupleProtocol oprot = (TTupleProtocol) prot;
      BitSet optionals = new BitSet();
      if (struct.isSetBoolField()) {
        optionals.set(0);
      }
      if (struct.isSetByteField()) {
        optionals.set(1);
      }
      if (struct.isSetByteOptionalField()) {
        optionals.set(2);
      }
      if (struct.isSetI16Field()) {
        optionals.set(3);
      }
      if (struct.isSetI16OptionalField()) {
        optionals.set(4);
      }
      if (struct.isSetI32Field()) {
        optionals.set(5);
      }
      if (struct.isSetI64Field()) {
        optionals.set(6);
      }
      if (struct.isSetDoubleField()) {
        optionals.set(7);
      }
      if (struct.isSetStringField()) {
        optionals.set(8);
      }
      if (struct.isSetBinaryField()) {
        optionals.set(9);
      }
      if (struct.isSetMapField()) {
        optionals.set(10);
      }
      if (struct.isSetListField()) {
        optionals.set(11);
      }
      if (struct.isSetSetField()) {
        optionals.set(12);
      }
      if (struct.isSetEnumField()) {
        optionals.set(13);
      }
      if (struct.isSetStructField()) {
        optionals.set(14);
      }
      if (struct.isSetFooOrBar()) {
        optionals.set(15);
      }
      oprot.writeBitSet(optionals, 16);
      if (struct.isSetBoolField()) {
        oprot.writeBool(struct.boolField);
      }
      if (struct.isSetByteField()) {
        oprot.writeByte(struct.byteField);
      }
      if (struct.isSetByteOptionalField()) {
        oprot.writeByte(struct.byteOptionalField);
      }
      if (struct.isSetI16Field()) {
        oprot.writeI16(struct.i16Field);
      }
      if (struct.isSetI16OptionalField()) {
        oprot.writeI16(struct.i16OptionalField);
      }
      if (struct.isSetI32Field()) {
        oprot.writeI32(struct.i32Field);
      }
      if (struct.isSetI64Field()) {
        oprot.writeI64(struct.i64Field);
      }
      if (struct.isSetDoubleField()) {
        oprot.writeDouble(struct.doubleField);
      }
      if (struct.isSetStringField()) {
        oprot.writeString(struct.stringField);
      }
      if (struct.isSetBinaryField()) {
        oprot.writeBinary(struct.binaryField);
      }
      if (struct.isSetMapField()) {
        {
          oprot.writeI32(struct.mapField.size());
          for (Map.Entry<String, Integer> _iter13 : struct.mapField.entrySet())
          {
            oprot.writeString(_iter13.getKey());
            oprot.writeI32(_iter13.getValue());
          }
        }
      }
      if (struct.isSetListField()) {
        {
          oprot.writeI32(struct.listField.size());
          for (int _iter14 : struct.listField)
          {
            oprot.writeI32(_iter14);
          }
        }
      }
      if (struct.isSetSetField()) {
        {
          oprot.writeI32(struct.setField.size());
          for (int _iter15 : struct.setField)
          {
            oprot.writeI32(_iter15);
          }
        }
      }
      if (struct.isSetEnumField()) {
        oprot.writeI32(struct.enumField.getValue());
      }
      if (struct.isSetStructField()) {
        struct.structField.write(oprot);
      }
      if (struct.isSetFooOrBar()) {
        struct.fooOrBar.write(oprot);
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, Test struct) throws org.apache.thrift.TException {
      TTupleProtocol iprot = (TTupleProtocol) prot;
      BitSet incoming = iprot.readBitSet(16);
      if (incoming.get(0)) {
        struct.boolField = iprot.readBool();
        struct.setBoolFieldIsSet(true);
      }
      if (incoming.get(1)) {
        struct.byteField = iprot.readByte();
        struct.setByteFieldIsSet(true);
      }
      if (incoming.get(2)) {
        struct.byteOptionalField = iprot.readByte();
        struct.setByteOptionalFieldIsSet(true);
      }
      if (incoming.get(3)) {
        struct.i16Field = iprot.readI16();
        struct.setI16FieldIsSet(true);
      }
      if (incoming.get(4)) {
        struct.i16OptionalField = iprot.readI16();
        struct.setI16OptionalFieldIsSet(true);
      }
      if (incoming.get(5)) {
        struct.i32Field = iprot.readI32();
        struct.setI32FieldIsSet(true);
      }
      if (incoming.get(6)) {
        struct.i64Field = iprot.readI64();
        struct.setI64FieldIsSet(true);
      }
      if (incoming.get(7)) {
        struct.doubleField = iprot.readDouble();
        struct.setDoubleFieldIsSet(true);
      }
      if (incoming.get(8)) {
        struct.stringField = iprot.readString();
        struct.setStringFieldIsSet(true);
      }
      if (incoming.get(9)) {
        struct.binaryField = iprot.readBinary();
        struct.setBinaryFieldIsSet(true);
      }
      if (incoming.get(10)) {
        {
          org.apache.thrift.protocol.TMap _map16 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.I32, iprot.readI32());
          struct.mapField = new HashMap<String,Integer>(2*_map16.size);
          for (int _i17 = 0; _i17 < _map16.size; ++_i17)
          {
            String _key18;
            int _val19;
            _key18 = iprot.readString();
            _val19 = iprot.readI32();
            struct.mapField.put(_key18, _val19);
          }
        }
        struct.setMapFieldIsSet(true);
      }
      if (incoming.get(11)) {
        {
          org.apache.thrift.protocol.TList _list20 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
          struct.listField = new ArrayList<Integer>(_list20.size);
          for (int _i21 = 0; _i21 < _list20.size; ++_i21)
          {
            int _elem22;
            _elem22 = iprot.readI32();
            struct.listField.add(_elem22);
          }
        }
        struct.setListFieldIsSet(true);
      }
      if (incoming.get(12)) {
        {
          org.apache.thrift.protocol.TSet _set23 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.I32, iprot.readI32());
          struct.setField = new HashSet<Integer>(2*_set23.size);
          for (int _i24 = 0; _i24 < _set23.size; ++_i24)
          {
            int _elem25;
            _elem25 = iprot.readI32();
            struct.setField.add(_elem25);
          }
        }
        struct.setSetFieldIsSet(true);
      }
      if (incoming.get(13)) {
        struct.enumField = E.findByValue(iprot.readI32());
        struct.setEnumFieldIsSet(true);
      }
      if (incoming.get(14)) {
        struct.structField = new Nested();
        struct.structField.read(iprot);
        struct.setStructFieldIsSet(true);
      }
      if (incoming.get(15)) {
        struct.fooOrBar = new FooOrBar();
        struct.fooOrBar.read(iprot);
        struct.setFooOrBarIsSet(true);
      }
    }
  }

}