/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.BitSet;
import java.util.Arrays;
import com.facebook.thrift.*;
import com.facebook.thrift.annotations.*;
import com.facebook.thrift.async.*;
import com.facebook.thrift.meta_data.*;
import com.facebook.thrift.server.*;
import com.facebook.thrift.transport.*;
import com.facebook.thrift.protocol.*;

@SuppressWarnings({ "unused", "serial" })
public class MyStruct implements TBase, java.io.Serializable, Cloneable {
  private static final TStruct STRUCT_DESC = new TStruct("MyStruct");
  private static final TField MY_INT_FIELD_FIELD_DESC = new TField("MyIntField", TType.I64, (short)1);
  private static final TField MY_STRING_FIELD_FIELD_DESC = new TField("MyStringField", TType.STRING, (short)2);
  private static final TField MY_DATA_FIELD_FIELD_DESC = new TField("MyDataField", TType.STRUCT, (short)3);
  private static final TField MY_ENUM_FIELD_DESC = new TField("myEnum", TType.I32, (short)4);
  private static final TField MY_BOOL_FIELD_FIELD_DESC = new TField("MyBoolField", TType.BOOL, (short)5);
  private static final TField MY_BYTE_FIELD_FIELD_DESC = new TField("MyByteField", TType.BYTE, (short)6);
  private static final TField MY_SHORT_FIELD_FIELD_DESC = new TField("MyShortField", TType.I16, (short)7);
  private static final TField MY_LONG_FIELD_FIELD_DESC = new TField("MyLongField", TType.I64, (short)8);
  private static final TField MY_DOUBLE_FIELD_FIELD_DESC = new TField("MyDoubleField", TType.DOUBLE, (short)9);
  private static final TField L_DOUBLE_FIELD_DESC = new TField("lDouble", TType.LIST, (short)10);
  private static final TField L_SHORT_FIELD_DESC = new TField("lShort", TType.LIST, (short)11);
  private static final TField L_INTEGER_FIELD_DESC = new TField("lInteger", TType.LIST, (short)12);
  private static final TField L_LONG_FIELD_DESC = new TField("lLong", TType.LIST, (short)13);
  private static final TField L_STRING_FIELD_DESC = new TField("lString", TType.LIST, (short)14);
  private static final TField L_BOOL_FIELD_DESC = new TField("lBool", TType.LIST, (short)15);
  private static final TField L_BYTE_FIELD_DESC = new TField("lByte", TType.LIST, (short)16);
  private static final TField M_SHORT_STRING_FIELD_DESC = new TField("mShortString", TType.MAP, (short)17);
  private static final TField M_INTEGER_STRING_FIELD_DESC = new TField("mIntegerString", TType.MAP, (short)18);
  private static final TField M_STRING_MY_STRUCT_FIELD_DESC = new TField("mStringMyStruct", TType.MAP, (short)19);
  private static final TField M_STRING_BOOL_FIELD_DESC = new TField("mStringBool", TType.MAP, (short)20);
  private static final TField M_INTEGER_INTEGER_FIELD_DESC = new TField("mIntegerInteger", TType.MAP, (short)21);
  private static final TField M_INTEGER_BOOL_FIELD_DESC = new TField("mIntegerBool", TType.MAP, (short)22);
  private static final TField S_SHORT_FIELD_DESC = new TField("sShort", TType.SET, (short)23);
  private static final TField S_MY_STRUCT_FIELD_DESC = new TField("sMyStruct", TType.SET, (short)24);
  private static final TField S_LONG_FIELD_DESC = new TField("sLong", TType.SET, (short)25);
  private static final TField S_STRING_FIELD_DESC = new TField("sString", TType.SET, (short)26);
  private static final TField S_BYTE_FIELD_DESC = new TField("sByte", TType.SET, (short)27);
  private static final TField M_LIST_LIST_FIELD_DESC = new TField("mListList", TType.MAP, (short)28);

  public long MyIntField;
  public String MyStringField;
  public MyDataItem MyDataField;
  /**
   * 
   * @see MyEnum
   */
  public MyEnum myEnum;
  public boolean MyBoolField;
  public byte MyByteField;
  public short MyShortField;
  public long MyLongField;
  public double MyDoubleField;
  public List<Double> lDouble;
  public List<Short> lShort;
  public List<Integer> lInteger;
  public List<Long> lLong;
  public List<String> lString;
  public List<Boolean> lBool;
  public List<Byte> lByte;
  public Map<Short,String> mShortString;
  public Map<Integer,String> mIntegerString;
  public Map<String,MyStruct> mStringMyStruct;
  public Map<String,Boolean> mStringBool;
  public Map<Integer,Integer> mIntegerInteger;
  public Map<Integer,Boolean> mIntegerBool;
  public Set<Short> sShort;
  public Set<MyStruct> sMyStruct;
  public Set<Long> sLong;
  public Set<String> sString;
  public Set<Byte> sByte;
  public Map<List<Integer>,List<Integer>> mListList;
  public static final int MYINTFIELD = 1;
  public static final int MYSTRINGFIELD = 2;
  public static final int MYDATAFIELD = 3;
  public static final int MYENUM = 4;
  public static final int MYBOOLFIELD = 5;
  public static final int MYBYTEFIELD = 6;
  public static final int MYSHORTFIELD = 7;
  public static final int MYLONGFIELD = 8;
  public static final int MYDOUBLEFIELD = 9;
  public static final int LDOUBLE = 10;
  public static final int LSHORT = 11;
  public static final int LINTEGER = 12;
  public static final int LLONG = 13;
  public static final int LSTRING = 14;
  public static final int LBOOL = 15;
  public static final int LBYTE = 16;
  public static final int MSHORTSTRING = 17;
  public static final int MINTEGERSTRING = 18;
  public static final int MSTRINGMYSTRUCT = 19;
  public static final int MSTRINGBOOL = 20;
  public static final int MINTEGERINTEGER = 21;
  public static final int MINTEGERBOOL = 22;
  public static final int SSHORT = 23;
  public static final int SMYSTRUCT = 24;
  public static final int SLONG = 25;
  public static final int SSTRING = 26;
  public static final int SBYTE = 27;
  public static final int MLISTLIST = 28;

  // isset id assignments
  private static final int __MYINTFIELD_ISSET_ID = 0;
  private static final int __MYBOOLFIELD_ISSET_ID = 1;
  private static final int __MYBYTEFIELD_ISSET_ID = 2;
  private static final int __MYSHORTFIELD_ISSET_ID = 3;
  private static final int __MYLONGFIELD_ISSET_ID = 4;
  private static final int __MYDOUBLEFIELD_ISSET_ID = 5;
  private BitSet __isset_bit_vector = new BitSet(6);

  public static final Map<Integer, FieldMetaData> metaDataMap;

  static {
    Map<Integer, FieldMetaData> tmpMetaDataMap = new HashMap<Integer, FieldMetaData>();
    tmpMetaDataMap.put(MYINTFIELD, new FieldMetaData("MyIntField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I64)));
    tmpMetaDataMap.put(MYSTRINGFIELD, new FieldMetaData("MyStringField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.STRING)));
    tmpMetaDataMap.put(MYDATAFIELD, new FieldMetaData("MyDataField", TFieldRequirementType.DEFAULT, 
        new StructMetaData(TType.STRUCT, MyDataItem.class)));
    tmpMetaDataMap.put(MYENUM, new FieldMetaData("myEnum", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I32)));
    tmpMetaDataMap.put(MYBOOLFIELD, new FieldMetaData("MyBoolField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.BOOL)));
    tmpMetaDataMap.put(MYBYTEFIELD, new FieldMetaData("MyByteField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.BYTE)));
    tmpMetaDataMap.put(MYSHORTFIELD, new FieldMetaData("MyShortField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I16)));
    tmpMetaDataMap.put(MYLONGFIELD, new FieldMetaData("MyLongField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I64)));
    tmpMetaDataMap.put(MYDOUBLEFIELD, new FieldMetaData("MyDoubleField", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.DOUBLE)));
    tmpMetaDataMap.put(LDOUBLE, new FieldMetaData("lDouble", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.DOUBLE))));
    tmpMetaDataMap.put(LSHORT, new FieldMetaData("lShort", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.I16))));
    tmpMetaDataMap.put(LINTEGER, new FieldMetaData("lInteger", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(LLONG, new FieldMetaData("lLong", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.I64))));
    tmpMetaDataMap.put(LSTRING, new FieldMetaData("lString", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(LBOOL, new FieldMetaData("lBool", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.BOOL))));
    tmpMetaDataMap.put(LBYTE, new FieldMetaData("lByte", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.BYTE))));
    tmpMetaDataMap.put(MSHORTSTRING, new FieldMetaData("mShortString", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I16), 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(MINTEGERSTRING, new FieldMetaData("mIntegerString", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(MSTRINGMYSTRUCT, new FieldMetaData("mStringMyStruct", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.STRING), 
            new StructMetaData(TType.STRUCT, MyStruct.class))));
    tmpMetaDataMap.put(MSTRINGBOOL, new FieldMetaData("mStringBool", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.STRING), 
            new FieldValueMetaData(TType.BOOL))));
    tmpMetaDataMap.put(MINTEGERINTEGER, new FieldMetaData("mIntegerInteger", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(MINTEGERBOOL, new FieldMetaData("mIntegerBool", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new FieldValueMetaData(TType.BOOL))));
    tmpMetaDataMap.put(SSHORT, new FieldMetaData("sShort", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new FieldValueMetaData(TType.I16))));
    tmpMetaDataMap.put(SMYSTRUCT, new FieldMetaData("sMyStruct", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new StructMetaData(TType.STRUCT, MyStruct.class))));
    tmpMetaDataMap.put(SLONG, new FieldMetaData("sLong", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new FieldValueMetaData(TType.I64))));
    tmpMetaDataMap.put(SSTRING, new FieldMetaData("sString", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(SBYTE, new FieldMetaData("sByte", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new FieldValueMetaData(TType.BYTE))));
    tmpMetaDataMap.put(MLISTLIST, new FieldMetaData("mListList", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new ListMetaData(TType.LIST, 
                new FieldValueMetaData(TType.I32)), 
            new ListMetaData(TType.LIST, 
                new FieldValueMetaData(TType.I32)))));
    metaDataMap = Collections.unmodifiableMap(tmpMetaDataMap);
  }

  static {
    FieldMetaData.addStructMetaDataMap(MyStruct.class, metaDataMap);
  }

  public MyStruct() {
  }

  public MyStruct(
      long MyIntField,
      String MyStringField,
      MyDataItem MyDataField,
      MyEnum myEnum,
      boolean MyBoolField,
      byte MyByteField,
      short MyShortField,
      long MyLongField,
      double MyDoubleField,
      List<Double> lDouble,
      List<Short> lShort,
      List<Integer> lInteger,
      List<Long> lLong,
      List<String> lString,
      List<Boolean> lBool,
      List<Byte> lByte,
      Map<Short,String> mShortString,
      Map<Integer,String> mIntegerString,
      Map<String,MyStruct> mStringMyStruct,
      Map<String,Boolean> mStringBool,
      Map<Integer,Integer> mIntegerInteger,
      Map<Integer,Boolean> mIntegerBool,
      Set<Short> sShort,
      Set<MyStruct> sMyStruct,
      Set<Long> sLong,
      Set<String> sString,
      Set<Byte> sByte,
      Map<List<Integer>,List<Integer>> mListList) {
    this();
    this.MyIntField = MyIntField;
    setMyIntFieldIsSet(true);
    this.MyStringField = MyStringField;
    this.MyDataField = MyDataField;
    this.myEnum = myEnum;
    this.MyBoolField = MyBoolField;
    setMyBoolFieldIsSet(true);
    this.MyByteField = MyByteField;
    setMyByteFieldIsSet(true);
    this.MyShortField = MyShortField;
    setMyShortFieldIsSet(true);
    this.MyLongField = MyLongField;
    setMyLongFieldIsSet(true);
    this.MyDoubleField = MyDoubleField;
    setMyDoubleFieldIsSet(true);
    this.lDouble = lDouble;
    this.lShort = lShort;
    this.lInteger = lInteger;
    this.lLong = lLong;
    this.lString = lString;
    this.lBool = lBool;
    this.lByte = lByte;
    this.mShortString = mShortString;
    this.mIntegerString = mIntegerString;
    this.mStringMyStruct = mStringMyStruct;
    this.mStringBool = mStringBool;
    this.mIntegerInteger = mIntegerInteger;
    this.mIntegerBool = mIntegerBool;
    this.sShort = sShort;
    this.sMyStruct = sMyStruct;
    this.sLong = sLong;
    this.sString = sString;
    this.sByte = sByte;
    this.mListList = mListList;
  }

  public static class Builder {
    private long MyIntField;
    private String MyStringField;
    private MyDataItem MyDataField;
    private MyEnum myEnum;
    private boolean MyBoolField;
    private byte MyByteField;
    private short MyShortField;
    private long MyLongField;
    private double MyDoubleField;
    private List<Double> lDouble;
    private List<Short> lShort;
    private List<Integer> lInteger;
    private List<Long> lLong;
    private List<String> lString;
    private List<Boolean> lBool;
    private List<Byte> lByte;
    private Map<Short,String> mShortString;
    private Map<Integer,String> mIntegerString;
    private Map<String,MyStruct> mStringMyStruct;
    private Map<String,Boolean> mStringBool;
    private Map<Integer,Integer> mIntegerInteger;
    private Map<Integer,Boolean> mIntegerBool;
    private Set<Short> sShort;
    private Set<MyStruct> sMyStruct;
    private Set<Long> sLong;
    private Set<String> sString;
    private Set<Byte> sByte;
    private Map<List<Integer>,List<Integer>> mListList;

    BitSet __optional_isset = new BitSet(6);

    public Builder() {
    }

    public Builder setMyIntField(final long MyIntField) {
      this.MyIntField = MyIntField;
      __optional_isset.set(__MYINTFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setMyStringField(final String MyStringField) {
      this.MyStringField = MyStringField;
      return this;
    }

    public Builder setMyDataField(final MyDataItem MyDataField) {
      this.MyDataField = MyDataField;
      return this;
    }

    public Builder setMyEnum(final MyEnum myEnum) {
      this.myEnum = myEnum;
      return this;
    }

    public Builder setMyBoolField(final boolean MyBoolField) {
      this.MyBoolField = MyBoolField;
      __optional_isset.set(__MYBOOLFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setMyByteField(final byte MyByteField) {
      this.MyByteField = MyByteField;
      __optional_isset.set(__MYBYTEFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setMyShortField(final short MyShortField) {
      this.MyShortField = MyShortField;
      __optional_isset.set(__MYSHORTFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setMyLongField(final long MyLongField) {
      this.MyLongField = MyLongField;
      __optional_isset.set(__MYLONGFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setMyDoubleField(final double MyDoubleField) {
      this.MyDoubleField = MyDoubleField;
      __optional_isset.set(__MYDOUBLEFIELD_ISSET_ID, true);
      return this;
    }

    public Builder setLDouble(final List<Double> lDouble) {
      this.lDouble = lDouble;
      return this;
    }

    public Builder setLShort(final List<Short> lShort) {
      this.lShort = lShort;
      return this;
    }

    public Builder setLInteger(final List<Integer> lInteger) {
      this.lInteger = lInteger;
      return this;
    }

    public Builder setLLong(final List<Long> lLong) {
      this.lLong = lLong;
      return this;
    }

    public Builder setLString(final List<String> lString) {
      this.lString = lString;
      return this;
    }

    public Builder setLBool(final List<Boolean> lBool) {
      this.lBool = lBool;
      return this;
    }

    public Builder setLByte(final List<Byte> lByte) {
      this.lByte = lByte;
      return this;
    }

    public Builder setMShortString(final Map<Short,String> mShortString) {
      this.mShortString = mShortString;
      return this;
    }

    public Builder setMIntegerString(final Map<Integer,String> mIntegerString) {
      this.mIntegerString = mIntegerString;
      return this;
    }

    public Builder setMStringMyStruct(final Map<String,MyStruct> mStringMyStruct) {
      this.mStringMyStruct = mStringMyStruct;
      return this;
    }

    public Builder setMStringBool(final Map<String,Boolean> mStringBool) {
      this.mStringBool = mStringBool;
      return this;
    }

    public Builder setMIntegerInteger(final Map<Integer,Integer> mIntegerInteger) {
      this.mIntegerInteger = mIntegerInteger;
      return this;
    }

    public Builder setMIntegerBool(final Map<Integer,Boolean> mIntegerBool) {
      this.mIntegerBool = mIntegerBool;
      return this;
    }

    public Builder setSShort(final Set<Short> sShort) {
      this.sShort = sShort;
      return this;
    }

    public Builder setSMyStruct(final Set<MyStruct> sMyStruct) {
      this.sMyStruct = sMyStruct;
      return this;
    }

    public Builder setSLong(final Set<Long> sLong) {
      this.sLong = sLong;
      return this;
    }

    public Builder setSString(final Set<String> sString) {
      this.sString = sString;
      return this;
    }

    public Builder setSByte(final Set<Byte> sByte) {
      this.sByte = sByte;
      return this;
    }

    public Builder setMListList(final Map<List<Integer>,List<Integer>> mListList) {
      this.mListList = mListList;
      return this;
    }

    public MyStruct build() {
      MyStruct result = new MyStruct();
      if (__optional_isset.get(__MYINTFIELD_ISSET_ID)) {
        result.setMyIntField(this.MyIntField);
      }
      result.setMyStringField(this.MyStringField);
      result.setMyDataField(this.MyDataField);
      result.setMyEnum(this.myEnum);
      if (__optional_isset.get(__MYBOOLFIELD_ISSET_ID)) {
        result.setMyBoolField(this.MyBoolField);
      }
      if (__optional_isset.get(__MYBYTEFIELD_ISSET_ID)) {
        result.setMyByteField(this.MyByteField);
      }
      if (__optional_isset.get(__MYSHORTFIELD_ISSET_ID)) {
        result.setMyShortField(this.MyShortField);
      }
      if (__optional_isset.get(__MYLONGFIELD_ISSET_ID)) {
        result.setMyLongField(this.MyLongField);
      }
      if (__optional_isset.get(__MYDOUBLEFIELD_ISSET_ID)) {
        result.setMyDoubleField(this.MyDoubleField);
      }
      result.setLDouble(this.lDouble);
      result.setLShort(this.lShort);
      result.setLInteger(this.lInteger);
      result.setLLong(this.lLong);
      result.setLString(this.lString);
      result.setLBool(this.lBool);
      result.setLByte(this.lByte);
      result.setMShortString(this.mShortString);
      result.setMIntegerString(this.mIntegerString);
      result.setMStringMyStruct(this.mStringMyStruct);
      result.setMStringBool(this.mStringBool);
      result.setMIntegerInteger(this.mIntegerInteger);
      result.setMIntegerBool(this.mIntegerBool);
      result.setSShort(this.sShort);
      result.setSMyStruct(this.sMyStruct);
      result.setSLong(this.sLong);
      result.setSString(this.sString);
      result.setSByte(this.sByte);
      result.setMListList(this.mListList);
      return result;
    }
  }

  public static Builder builder() {
    return new Builder();
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public MyStruct(MyStruct other) {
    __isset_bit_vector.clear();
    __isset_bit_vector.or(other.__isset_bit_vector);
    this.MyIntField = TBaseHelper.deepCopy(other.MyIntField);
    if (other.isSetMyStringField()) {
      this.MyStringField = TBaseHelper.deepCopy(other.MyStringField);
    }
    if (other.isSetMyDataField()) {
      this.MyDataField = TBaseHelper.deepCopy(other.MyDataField);
    }
    if (other.isSetMyEnum()) {
      this.myEnum = TBaseHelper.deepCopy(other.myEnum);
    }
    this.MyBoolField = TBaseHelper.deepCopy(other.MyBoolField);
    this.MyByteField = TBaseHelper.deepCopy(other.MyByteField);
    this.MyShortField = TBaseHelper.deepCopy(other.MyShortField);
    this.MyLongField = TBaseHelper.deepCopy(other.MyLongField);
    this.MyDoubleField = TBaseHelper.deepCopy(other.MyDoubleField);
    if (other.isSetLDouble()) {
      this.lDouble = TBaseHelper.deepCopy(other.lDouble);
    }
    if (other.isSetLShort()) {
      this.lShort = TBaseHelper.deepCopy(other.lShort);
    }
    if (other.isSetLInteger()) {
      this.lInteger = TBaseHelper.deepCopy(other.lInteger);
    }
    if (other.isSetLLong()) {
      this.lLong = TBaseHelper.deepCopy(other.lLong);
    }
    if (other.isSetLString()) {
      this.lString = TBaseHelper.deepCopy(other.lString);
    }
    if (other.isSetLBool()) {
      this.lBool = TBaseHelper.deepCopy(other.lBool);
    }
    if (other.isSetLByte()) {
      this.lByte = TBaseHelper.deepCopy(other.lByte);
    }
    if (other.isSetMShortString()) {
      this.mShortString = TBaseHelper.deepCopy(other.mShortString);
    }
    if (other.isSetMIntegerString()) {
      this.mIntegerString = TBaseHelper.deepCopy(other.mIntegerString);
    }
    if (other.isSetMStringMyStruct()) {
      this.mStringMyStruct = TBaseHelper.deepCopy(other.mStringMyStruct);
    }
    if (other.isSetMStringBool()) {
      this.mStringBool = TBaseHelper.deepCopy(other.mStringBool);
    }
    if (other.isSetMIntegerInteger()) {
      this.mIntegerInteger = TBaseHelper.deepCopy(other.mIntegerInteger);
    }
    if (other.isSetMIntegerBool()) {
      this.mIntegerBool = TBaseHelper.deepCopy(other.mIntegerBool);
    }
    if (other.isSetSShort()) {
      this.sShort = TBaseHelper.deepCopy(other.sShort);
    }
    if (other.isSetSMyStruct()) {
      this.sMyStruct = TBaseHelper.deepCopy(other.sMyStruct);
    }
    if (other.isSetSLong()) {
      this.sLong = TBaseHelper.deepCopy(other.sLong);
    }
    if (other.isSetSString()) {
      this.sString = TBaseHelper.deepCopy(other.sString);
    }
    if (other.isSetSByte()) {
      this.sByte = TBaseHelper.deepCopy(other.sByte);
    }
    if (other.isSetMListList()) {
      this.mListList = TBaseHelper.deepCopy(other.mListList);
    }
  }

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

  public long getMyIntField() {
    return this.MyIntField;
  }

  public MyStruct setMyIntField(long MyIntField) {
    this.MyIntField = MyIntField;
    setMyIntFieldIsSet(true);
    return this;
  }

  public void unsetMyIntField() {
    __isset_bit_vector.clear(__MYINTFIELD_ISSET_ID);
  }

  // Returns true if field MyIntField is set (has been assigned a value) and false otherwise
  public boolean isSetMyIntField() {
    return __isset_bit_vector.get(__MYINTFIELD_ISSET_ID);
  }

  public void setMyIntFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYINTFIELD_ISSET_ID, __value);
  }

  public String getMyStringField() {
    return this.MyStringField;
  }

  public MyStruct setMyStringField(String MyStringField) {
    this.MyStringField = MyStringField;
    return this;
  }

  public void unsetMyStringField() {
    this.MyStringField = null;
  }

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

  public void setMyStringFieldIsSet(boolean __value) {
    if (!__value) {
      this.MyStringField = null;
    }
  }

  public MyDataItem getMyDataField() {
    return this.MyDataField;
  }

  public MyStruct setMyDataField(MyDataItem MyDataField) {
    this.MyDataField = MyDataField;
    return this;
  }

  public void unsetMyDataField() {
    this.MyDataField = null;
  }

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

  public void setMyDataFieldIsSet(boolean __value) {
    if (!__value) {
      this.MyDataField = null;
    }
  }

  /**
   * 
   * @see MyEnum
   */
  public MyEnum getMyEnum() {
    return this.myEnum;
  }

  /**
   * 
   * @see MyEnum
   */
  public MyStruct setMyEnum(MyEnum myEnum) {
    this.myEnum = myEnum;
    return this;
  }

  public void unsetMyEnum() {
    this.myEnum = null;
  }

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

  public void setMyEnumIsSet(boolean __value) {
    if (!__value) {
      this.myEnum = null;
    }
  }

  public boolean isMyBoolField() {
    return this.MyBoolField;
  }

  public MyStruct setMyBoolField(boolean MyBoolField) {
    this.MyBoolField = MyBoolField;
    setMyBoolFieldIsSet(true);
    return this;
  }

  public void unsetMyBoolField() {
    __isset_bit_vector.clear(__MYBOOLFIELD_ISSET_ID);
  }

  // Returns true if field MyBoolField is set (has been assigned a value) and false otherwise
  public boolean isSetMyBoolField() {
    return __isset_bit_vector.get(__MYBOOLFIELD_ISSET_ID);
  }

  public void setMyBoolFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYBOOLFIELD_ISSET_ID, __value);
  }

  public byte getMyByteField() {
    return this.MyByteField;
  }

  public MyStruct setMyByteField(byte MyByteField) {
    this.MyByteField = MyByteField;
    setMyByteFieldIsSet(true);
    return this;
  }

  public void unsetMyByteField() {
    __isset_bit_vector.clear(__MYBYTEFIELD_ISSET_ID);
  }

  // Returns true if field MyByteField is set (has been assigned a value) and false otherwise
  public boolean isSetMyByteField() {
    return __isset_bit_vector.get(__MYBYTEFIELD_ISSET_ID);
  }

  public void setMyByteFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYBYTEFIELD_ISSET_ID, __value);
  }

  public short getMyShortField() {
    return this.MyShortField;
  }

  public MyStruct setMyShortField(short MyShortField) {
    this.MyShortField = MyShortField;
    setMyShortFieldIsSet(true);
    return this;
  }

  public void unsetMyShortField() {
    __isset_bit_vector.clear(__MYSHORTFIELD_ISSET_ID);
  }

  // Returns true if field MyShortField is set (has been assigned a value) and false otherwise
  public boolean isSetMyShortField() {
    return __isset_bit_vector.get(__MYSHORTFIELD_ISSET_ID);
  }

  public void setMyShortFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYSHORTFIELD_ISSET_ID, __value);
  }

  public long getMyLongField() {
    return this.MyLongField;
  }

  public MyStruct setMyLongField(long MyLongField) {
    this.MyLongField = MyLongField;
    setMyLongFieldIsSet(true);
    return this;
  }

  public void unsetMyLongField() {
    __isset_bit_vector.clear(__MYLONGFIELD_ISSET_ID);
  }

  // Returns true if field MyLongField is set (has been assigned a value) and false otherwise
  public boolean isSetMyLongField() {
    return __isset_bit_vector.get(__MYLONGFIELD_ISSET_ID);
  }

  public void setMyLongFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYLONGFIELD_ISSET_ID, __value);
  }

  public double getMyDoubleField() {
    return this.MyDoubleField;
  }

  public MyStruct setMyDoubleField(double MyDoubleField) {
    this.MyDoubleField = MyDoubleField;
    setMyDoubleFieldIsSet(true);
    return this;
  }

  public void unsetMyDoubleField() {
    __isset_bit_vector.clear(__MYDOUBLEFIELD_ISSET_ID);
  }

  // Returns true if field MyDoubleField is set (has been assigned a value) and false otherwise
  public boolean isSetMyDoubleField() {
    return __isset_bit_vector.get(__MYDOUBLEFIELD_ISSET_ID);
  }

  public void setMyDoubleFieldIsSet(boolean __value) {
    __isset_bit_vector.set(__MYDOUBLEFIELD_ISSET_ID, __value);
  }

  public List<Double> getLDouble() {
    return this.lDouble;
  }

  public MyStruct setLDouble(List<Double> lDouble) {
    this.lDouble = lDouble;
    return this;
  }

  public void unsetLDouble() {
    this.lDouble = null;
  }

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

  public void setLDoubleIsSet(boolean __value) {
    if (!__value) {
      this.lDouble = null;
    }
  }

  public List<Short> getLShort() {
    return this.lShort;
  }

  public MyStruct setLShort(List<Short> lShort) {
    this.lShort = lShort;
    return this;
  }

  public void unsetLShort() {
    this.lShort = null;
  }

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

  public void setLShortIsSet(boolean __value) {
    if (!__value) {
      this.lShort = null;
    }
  }

  public List<Integer> getLInteger() {
    return this.lInteger;
  }

  public MyStruct setLInteger(List<Integer> lInteger) {
    this.lInteger = lInteger;
    return this;
  }

  public void unsetLInteger() {
    this.lInteger = null;
  }

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

  public void setLIntegerIsSet(boolean __value) {
    if (!__value) {
      this.lInteger = null;
    }
  }

  public List<Long> getLLong() {
    return this.lLong;
  }

  public MyStruct setLLong(List<Long> lLong) {
    this.lLong = lLong;
    return this;
  }

  public void unsetLLong() {
    this.lLong = null;
  }

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

  public void setLLongIsSet(boolean __value) {
    if (!__value) {
      this.lLong = null;
    }
  }

  public List<String> getLString() {
    return this.lString;
  }

  public MyStruct setLString(List<String> lString) {
    this.lString = lString;
    return this;
  }

  public void unsetLString() {
    this.lString = null;
  }

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

  public void setLStringIsSet(boolean __value) {
    if (!__value) {
      this.lString = null;
    }
  }

  public List<Boolean> getLBool() {
    return this.lBool;
  }

  public MyStruct setLBool(List<Boolean> lBool) {
    this.lBool = lBool;
    return this;
  }

  public void unsetLBool() {
    this.lBool = null;
  }

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

  public void setLBoolIsSet(boolean __value) {
    if (!__value) {
      this.lBool = null;
    }
  }

  public List<Byte> getLByte() {
    return this.lByte;
  }

  public MyStruct setLByte(List<Byte> lByte) {
    this.lByte = lByte;
    return this;
  }

  public void unsetLByte() {
    this.lByte = null;
  }

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

  public void setLByteIsSet(boolean __value) {
    if (!__value) {
      this.lByte = null;
    }
  }

  public Map<Short,String> getMShortString() {
    return this.mShortString;
  }

  public MyStruct setMShortString(Map<Short,String> mShortString) {
    this.mShortString = mShortString;
    return this;
  }

  public void unsetMShortString() {
    this.mShortString = null;
  }

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

  public void setMShortStringIsSet(boolean __value) {
    if (!__value) {
      this.mShortString = null;
    }
  }

  public Map<Integer,String> getMIntegerString() {
    return this.mIntegerString;
  }

  public MyStruct setMIntegerString(Map<Integer,String> mIntegerString) {
    this.mIntegerString = mIntegerString;
    return this;
  }

  public void unsetMIntegerString() {
    this.mIntegerString = null;
  }

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

  public void setMIntegerStringIsSet(boolean __value) {
    if (!__value) {
      this.mIntegerString = null;
    }
  }

  public Map<String,MyStruct> getMStringMyStruct() {
    return this.mStringMyStruct;
  }

  public MyStruct setMStringMyStruct(Map<String,MyStruct> mStringMyStruct) {
    this.mStringMyStruct = mStringMyStruct;
    return this;
  }

  public void unsetMStringMyStruct() {
    this.mStringMyStruct = null;
  }

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

  public void setMStringMyStructIsSet(boolean __value) {
    if (!__value) {
      this.mStringMyStruct = null;
    }
  }

  public Map<String,Boolean> getMStringBool() {
    return this.mStringBool;
  }

  public MyStruct setMStringBool(Map<String,Boolean> mStringBool) {
    this.mStringBool = mStringBool;
    return this;
  }

  public void unsetMStringBool() {
    this.mStringBool = null;
  }

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

  public void setMStringBoolIsSet(boolean __value) {
    if (!__value) {
      this.mStringBool = null;
    }
  }

  public Map<Integer,Integer> getMIntegerInteger() {
    return this.mIntegerInteger;
  }

  public MyStruct setMIntegerInteger(Map<Integer,Integer> mIntegerInteger) {
    this.mIntegerInteger = mIntegerInteger;
    return this;
  }

  public void unsetMIntegerInteger() {
    this.mIntegerInteger = null;
  }

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

  public void setMIntegerIntegerIsSet(boolean __value) {
    if (!__value) {
      this.mIntegerInteger = null;
    }
  }

  public Map<Integer,Boolean> getMIntegerBool() {
    return this.mIntegerBool;
  }

  public MyStruct setMIntegerBool(Map<Integer,Boolean> mIntegerBool) {
    this.mIntegerBool = mIntegerBool;
    return this;
  }

  public void unsetMIntegerBool() {
    this.mIntegerBool = null;
  }

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

  public void setMIntegerBoolIsSet(boolean __value) {
    if (!__value) {
      this.mIntegerBool = null;
    }
  }

  public Set<Short> getSShort() {
    return this.sShort;
  }

  public MyStruct setSShort(Set<Short> sShort) {
    this.sShort = sShort;
    return this;
  }

  public void unsetSShort() {
    this.sShort = null;
  }

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

  public void setSShortIsSet(boolean __value) {
    if (!__value) {
      this.sShort = null;
    }
  }

  public Set<MyStruct> getSMyStruct() {
    return this.sMyStruct;
  }

  public MyStruct setSMyStruct(Set<MyStruct> sMyStruct) {
    this.sMyStruct = sMyStruct;
    return this;
  }

  public void unsetSMyStruct() {
    this.sMyStruct = null;
  }

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

  public void setSMyStructIsSet(boolean __value) {
    if (!__value) {
      this.sMyStruct = null;
    }
  }

  public Set<Long> getSLong() {
    return this.sLong;
  }

  public MyStruct setSLong(Set<Long> sLong) {
    this.sLong = sLong;
    return this;
  }

  public void unsetSLong() {
    this.sLong = null;
  }

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

  public void setSLongIsSet(boolean __value) {
    if (!__value) {
      this.sLong = null;
    }
  }

  public Set<String> getSString() {
    return this.sString;
  }

  public MyStruct setSString(Set<String> sString) {
    this.sString = sString;
    return this;
  }

  public void unsetSString() {
    this.sString = null;
  }

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

  public void setSStringIsSet(boolean __value) {
    if (!__value) {
      this.sString = null;
    }
  }

  public Set<Byte> getSByte() {
    return this.sByte;
  }

  public MyStruct setSByte(Set<Byte> sByte) {
    this.sByte = sByte;
    return this;
  }

  public void unsetSByte() {
    this.sByte = null;
  }

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

  public void setSByteIsSet(boolean __value) {
    if (!__value) {
      this.sByte = null;
    }
  }

  public Map<List<Integer>,List<Integer>> getMListList() {
    return this.mListList;
  }

  public MyStruct setMListList(Map<List<Integer>,List<Integer>> mListList) {
    this.mListList = mListList;
    return this;
  }

  public void unsetMListList() {
    this.mListList = null;
  }

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

  public void setMListListIsSet(boolean __value) {
    if (!__value) {
      this.mListList = null;
    }
  }

  @SuppressWarnings("unchecked")
  public void setFieldValue(int fieldID, Object __value) {
    switch (fieldID) {
    case MYINTFIELD:
      if (__value == null) {
        unsetMyIntField();
      } else {
        setMyIntField((Long)__value);
      }
      break;

    case MYSTRINGFIELD:
      if (__value == null) {
        unsetMyStringField();
      } else {
        setMyStringField((String)__value);
      }
      break;

    case MYDATAFIELD:
      if (__value == null) {
        unsetMyDataField();
      } else {
        setMyDataField((MyDataItem)__value);
      }
      break;

    case MYENUM:
      if (__value == null) {
        unsetMyEnum();
      } else {
        setMyEnum((MyEnum)__value);
      }
      break;

    case MYBOOLFIELD:
      if (__value == null) {
        unsetMyBoolField();
      } else {
        setMyBoolField((Boolean)__value);
      }
      break;

    case MYBYTEFIELD:
      if (__value == null) {
        unsetMyByteField();
      } else {
        setMyByteField((Byte)__value);
      }
      break;

    case MYSHORTFIELD:
      if (__value == null) {
        unsetMyShortField();
      } else {
        setMyShortField((Short)__value);
      }
      break;

    case MYLONGFIELD:
      if (__value == null) {
        unsetMyLongField();
      } else {
        setMyLongField((Long)__value);
      }
      break;

    case MYDOUBLEFIELD:
      if (__value == null) {
        unsetMyDoubleField();
      } else {
        setMyDoubleField((Double)__value);
      }
      break;

    case LDOUBLE:
      if (__value == null) {
        unsetLDouble();
      } else {
        setLDouble((List<Double>)__value);
      }
      break;

    case LSHORT:
      if (__value == null) {
        unsetLShort();
      } else {
        setLShort((List<Short>)__value);
      }
      break;

    case LINTEGER:
      if (__value == null) {
        unsetLInteger();
      } else {
        setLInteger((List<Integer>)__value);
      }
      break;

    case LLONG:
      if (__value == null) {
        unsetLLong();
      } else {
        setLLong((List<Long>)__value);
      }
      break;

    case LSTRING:
      if (__value == null) {
        unsetLString();
      } else {
        setLString((List<String>)__value);
      }
      break;

    case LBOOL:
      if (__value == null) {
        unsetLBool();
      } else {
        setLBool((List<Boolean>)__value);
      }
      break;

    case LBYTE:
      if (__value == null) {
        unsetLByte();
      } else {
        setLByte((List<Byte>)__value);
      }
      break;

    case MSHORTSTRING:
      if (__value == null) {
        unsetMShortString();
      } else {
        setMShortString((Map<Short,String>)__value);
      }
      break;

    case MINTEGERSTRING:
      if (__value == null) {
        unsetMIntegerString();
      } else {
        setMIntegerString((Map<Integer,String>)__value);
      }
      break;

    case MSTRINGMYSTRUCT:
      if (__value == null) {
        unsetMStringMyStruct();
      } else {
        setMStringMyStruct((Map<String,MyStruct>)__value);
      }
      break;

    case MSTRINGBOOL:
      if (__value == null) {
        unsetMStringBool();
      } else {
        setMStringBool((Map<String,Boolean>)__value);
      }
      break;

    case MINTEGERINTEGER:
      if (__value == null) {
        unsetMIntegerInteger();
      } else {
        setMIntegerInteger((Map<Integer,Integer>)__value);
      }
      break;

    case MINTEGERBOOL:
      if (__value == null) {
        unsetMIntegerBool();
      } else {
        setMIntegerBool((Map<Integer,Boolean>)__value);
      }
      break;

    case SSHORT:
      if (__value == null) {
        unsetSShort();
      } else {
        setSShort((Set<Short>)__value);
      }
      break;

    case SMYSTRUCT:
      if (__value == null) {
        unsetSMyStruct();
      } else {
        setSMyStruct((Set<MyStruct>)__value);
      }
      break;

    case SLONG:
      if (__value == null) {
        unsetSLong();
      } else {
        setSLong((Set<Long>)__value);
      }
      break;

    case SSTRING:
      if (__value == null) {
        unsetSString();
      } else {
        setSString((Set<String>)__value);
      }
      break;

    case SBYTE:
      if (__value == null) {
        unsetSByte();
      } else {
        setSByte((Set<Byte>)__value);
      }
      break;

    case MLISTLIST:
      if (__value == null) {
        unsetMListList();
      } else {
        setMListList((Map<List<Integer>,List<Integer>>)__value);
      }
      break;

    default:
      throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
    }
  }

  public Object getFieldValue(int fieldID) {
    switch (fieldID) {
    case MYINTFIELD:
      return new Long(getMyIntField());

    case MYSTRINGFIELD:
      return getMyStringField();

    case MYDATAFIELD:
      return getMyDataField();

    case MYENUM:
      return getMyEnum();

    case MYBOOLFIELD:
      return new Boolean(isMyBoolField());

    case MYBYTEFIELD:
      return new Byte(getMyByteField());

    case MYSHORTFIELD:
      return new Short(getMyShortField());

    case MYLONGFIELD:
      return new Long(getMyLongField());

    case MYDOUBLEFIELD:
      return new Double(getMyDoubleField());

    case LDOUBLE:
      return getLDouble();

    case LSHORT:
      return getLShort();

    case LINTEGER:
      return getLInteger();

    case LLONG:
      return getLLong();

    case LSTRING:
      return getLString();

    case LBOOL:
      return getLBool();

    case LBYTE:
      return getLByte();

    case MSHORTSTRING:
      return getMShortString();

    case MINTEGERSTRING:
      return getMIntegerString();

    case MSTRINGMYSTRUCT:
      return getMStringMyStruct();

    case MSTRINGBOOL:
      return getMStringBool();

    case MINTEGERINTEGER:
      return getMIntegerInteger();

    case MINTEGERBOOL:
      return getMIntegerBool();

    case SSHORT:
      return getSShort();

    case SMYSTRUCT:
      return getSMyStruct();

    case SLONG:
      return getSLong();

    case SSTRING:
      return getSString();

    case SBYTE:
      return getSByte();

    case MLISTLIST:
      return getMListList();

    default:
      throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
    }
  }

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

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

    if (!TBaseHelper.equalsNobinary(this.isSetMyStringField(), that.isSetMyStringField(), this.MyStringField, that.MyStringField)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMyDataField(), that.isSetMyDataField(), this.MyDataField, that.MyDataField)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMyEnum(), that.isSetMyEnum(), this.myEnum, that.myEnum)) { return false; }

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

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

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

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

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

    if (!TBaseHelper.equalsNobinary(this.isSetLDouble(), that.isSetLDouble(), this.lDouble, that.lDouble)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLShort(), that.isSetLShort(), this.lShort, that.lShort)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLInteger(), that.isSetLInteger(), this.lInteger, that.lInteger)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLLong(), that.isSetLLong(), this.lLong, that.lLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLString(), that.isSetLString(), this.lString, that.lString)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLBool(), that.isSetLBool(), this.lBool, that.lBool)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetLByte(), that.isSetLByte(), this.lByte, that.lByte)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMShortString(), that.isSetMShortString(), this.mShortString, that.mShortString)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMIntegerString(), that.isSetMIntegerString(), this.mIntegerString, that.mIntegerString)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMStringMyStruct(), that.isSetMStringMyStruct(), this.mStringMyStruct, that.mStringMyStruct)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMStringBool(), that.isSetMStringBool(), this.mStringBool, that.mStringBool)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMIntegerInteger(), that.isSetMIntegerInteger(), this.mIntegerInteger, that.mIntegerInteger)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMIntegerBool(), that.isSetMIntegerBool(), this.mIntegerBool, that.mIntegerBool)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSShort(), that.isSetSShort(), this.sShort, that.sShort)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSMyStruct(), that.isSetSMyStruct(), this.sMyStruct, that.sMyStruct)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSLong(), that.isSetSLong(), this.sLong, that.sLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSString(), that.isSetSString(), this.sString, that.sString)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSByte(), that.isSetSByte(), this.sByte, that.sByte)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMListList(), that.isSetMListList(), this.mListList, that.mListList)) { return false; }

    return true;
  }

  @Override
  public int hashCode() {
    return Arrays.deepHashCode(new Object[] {MyIntField, MyStringField, MyDataField, myEnum, MyBoolField, MyByteField, MyShortField, MyLongField, MyDoubleField, lDouble, lShort, lInteger, lLong, lString, lBool, lByte, mShortString, mIntegerString, mStringMyStruct, mStringBool, mIntegerInteger, mIntegerBool, sShort, sMyStruct, sLong, sString, sByte, mListList});
  }

  public void read(TProtocol iprot) throws TException {
    TField __field;
    iprot.readStructBegin(metaDataMap);
    while (true)
    {
      __field = iprot.readFieldBegin();
      if (__field.type == TType.STOP) {
        break;
      }
      switch (__field.id)
      {
        case MYINTFIELD:
          if (__field.type == TType.I64) {
            this.MyIntField = iprot.readI64();
            setMyIntFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYSTRINGFIELD:
          if (__field.type == TType.STRING) {
            this.MyStringField = iprot.readString();
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYDATAFIELD:
          if (__field.type == TType.STRUCT) {
            this.MyDataField = new MyDataItem();
            this.MyDataField.read(iprot);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYENUM:
          if (__field.type == TType.I32) {
            this.myEnum = MyEnum.findByValue(iprot.readI32());
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBOOLFIELD:
          if (__field.type == TType.BOOL) {
            this.MyBoolField = iprot.readBool();
            setMyBoolFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBYTEFIELD:
          if (__field.type == TType.BYTE) {
            this.MyByteField = iprot.readByte();
            setMyByteFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYSHORTFIELD:
          if (__field.type == TType.I16) {
            this.MyShortField = iprot.readI16();
            setMyShortFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYLONGFIELD:
          if (__field.type == TType.I64) {
            this.MyLongField = iprot.readI64();
            setMyLongFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYDOUBLEFIELD:
          if (__field.type == TType.DOUBLE) {
            this.MyDoubleField = iprot.readDouble();
            setMyDoubleFieldIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LDOUBLE:
          if (__field.type == TType.LIST) {
            {
              TList _list13 = iprot.readListBegin();
              this.lDouble = new ArrayList<Double>(Math.max(0, _list13.size));
              for (int _i14 = 0; 
                   (_list13.size < 0) ? iprot.peekList() : (_i14 < _list13.size); 
                   ++_i14)
              {
                double _elem15;
                _elem15 = iprot.readDouble();
                this.lDouble.add(_elem15);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LSHORT:
          if (__field.type == TType.LIST) {
            {
              TList _list16 = iprot.readListBegin();
              this.lShort = new ArrayList<Short>(Math.max(0, _list16.size));
              for (int _i17 = 0; 
                   (_list16.size < 0) ? iprot.peekList() : (_i17 < _list16.size); 
                   ++_i17)
              {
                short _elem18;
                _elem18 = iprot.readI16();
                this.lShort.add(_elem18);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LINTEGER:
          if (__field.type == TType.LIST) {
            {
              TList _list19 = iprot.readListBegin();
              this.lInteger = new ArrayList<Integer>(Math.max(0, _list19.size));
              for (int _i20 = 0; 
                   (_list19.size < 0) ? iprot.peekList() : (_i20 < _list19.size); 
                   ++_i20)
              {
                int _elem21;
                _elem21 = iprot.readI32();
                this.lInteger.add(_elem21);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LLONG:
          if (__field.type == TType.LIST) {
            {
              TList _list22 = iprot.readListBegin();
              this.lLong = new ArrayList<Long>(Math.max(0, _list22.size));
              for (int _i23 = 0; 
                   (_list22.size < 0) ? iprot.peekList() : (_i23 < _list22.size); 
                   ++_i23)
              {
                long _elem24;
                _elem24 = iprot.readI64();
                this.lLong.add(_elem24);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LSTRING:
          if (__field.type == TType.LIST) {
            {
              TList _list25 = iprot.readListBegin();
              this.lString = new ArrayList<String>(Math.max(0, _list25.size));
              for (int _i26 = 0; 
                   (_list25.size < 0) ? iprot.peekList() : (_i26 < _list25.size); 
                   ++_i26)
              {
                String _elem27;
                _elem27 = iprot.readString();
                this.lString.add(_elem27);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LBOOL:
          if (__field.type == TType.LIST) {
            {
              TList _list28 = iprot.readListBegin();
              this.lBool = new ArrayList<Boolean>(Math.max(0, _list28.size));
              for (int _i29 = 0; 
                   (_list28.size < 0) ? iprot.peekList() : (_i29 < _list28.size); 
                   ++_i29)
              {
                boolean _elem30;
                _elem30 = iprot.readBool();
                this.lBool.add(_elem30);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LBYTE:
          if (__field.type == TType.LIST) {
            {
              TList _list31 = iprot.readListBegin();
              this.lByte = new ArrayList<Byte>(Math.max(0, _list31.size));
              for (int _i32 = 0; 
                   (_list31.size < 0) ? iprot.peekList() : (_i32 < _list31.size); 
                   ++_i32)
              {
                byte _elem33;
                _elem33 = iprot.readByte();
                this.lByte.add(_elem33);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MSHORTSTRING:
          if (__field.type == TType.MAP) {
            {
              TMap _map34 = iprot.readMapBegin();
              this.mShortString = new HashMap<Short,String>(Math.max(0, 2*_map34.size));
              for (int _i35 = 0; 
                   (_map34.size < 0) ? iprot.peekMap() : (_i35 < _map34.size); 
                   ++_i35)
              {
                short _key36;
                String _val37;
                _key36 = iprot.readI16();
                _val37 = iprot.readString();
                this.mShortString.put(_key36, _val37);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MINTEGERSTRING:
          if (__field.type == TType.MAP) {
            {
              TMap _map38 = iprot.readMapBegin();
              this.mIntegerString = new HashMap<Integer,String>(Math.max(0, 2*_map38.size));
              for (int _i39 = 0; 
                   (_map38.size < 0) ? iprot.peekMap() : (_i39 < _map38.size); 
                   ++_i39)
              {
                int _key40;
                String _val41;
                _key40 = iprot.readI32();
                _val41 = iprot.readString();
                this.mIntegerString.put(_key40, _val41);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MSTRINGMYSTRUCT:
          if (__field.type == TType.MAP) {
            {
              TMap _map42 = iprot.readMapBegin();
              this.mStringMyStruct = new HashMap<String,MyStruct>(Math.max(0, 2*_map42.size));
              for (int _i43 = 0; 
                   (_map42.size < 0) ? iprot.peekMap() : (_i43 < _map42.size); 
                   ++_i43)
              {
                String _key44;
                MyStruct _val45;
                _key44 = iprot.readString();
                _val45 = new MyStruct();
                _val45.read(iprot);
                this.mStringMyStruct.put(_key44, _val45);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MSTRINGBOOL:
          if (__field.type == TType.MAP) {
            {
              TMap _map46 = iprot.readMapBegin();
              this.mStringBool = new HashMap<String,Boolean>(Math.max(0, 2*_map46.size));
              for (int _i47 = 0; 
                   (_map46.size < 0) ? iprot.peekMap() : (_i47 < _map46.size); 
                   ++_i47)
              {
                String _key48;
                boolean _val49;
                _key48 = iprot.readString();
                _val49 = iprot.readBool();
                this.mStringBool.put(_key48, _val49);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MINTEGERINTEGER:
          if (__field.type == TType.MAP) {
            {
              TMap _map50 = iprot.readMapBegin();
              this.mIntegerInteger = new HashMap<Integer,Integer>(Math.max(0, 2*_map50.size));
              for (int _i51 = 0; 
                   (_map50.size < 0) ? iprot.peekMap() : (_i51 < _map50.size); 
                   ++_i51)
              {
                int _key52;
                int _val53;
                _key52 = iprot.readI32();
                _val53 = iprot.readI32();
                this.mIntegerInteger.put(_key52, _val53);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MINTEGERBOOL:
          if (__field.type == TType.MAP) {
            {
              TMap _map54 = iprot.readMapBegin();
              this.mIntegerBool = new HashMap<Integer,Boolean>(Math.max(0, 2*_map54.size));
              for (int _i55 = 0; 
                   (_map54.size < 0) ? iprot.peekMap() : (_i55 < _map54.size); 
                   ++_i55)
              {
                int _key56;
                boolean _val57;
                _key56 = iprot.readI32();
                _val57 = iprot.readBool();
                this.mIntegerBool.put(_key56, _val57);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SSHORT:
          if (__field.type == TType.SET) {
            {
              TSet _set58 = iprot.readSetBegin();
              this.sShort = new HashSet<Short>(Math.max(0, 2*_set58.size));
              for (int _i59 = 0; 
                   (_set58.size < 0) ? iprot.peekSet() : (_i59 < _set58.size); 
                   ++_i59)
              {
                short _elem60;
                _elem60 = iprot.readI16();
                this.sShort.add(_elem60);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SMYSTRUCT:
          if (__field.type == TType.SET) {
            {
              TSet _set61 = iprot.readSetBegin();
              this.sMyStruct = new HashSet<MyStruct>(Math.max(0, 2*_set61.size));
              for (int _i62 = 0; 
                   (_set61.size < 0) ? iprot.peekSet() : (_i62 < _set61.size); 
                   ++_i62)
              {
                MyStruct _elem63;
                _elem63 = new MyStruct();
                _elem63.read(iprot);
                this.sMyStruct.add(_elem63);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SLONG:
          if (__field.type == TType.SET) {
            {
              TSet _set64 = iprot.readSetBegin();
              this.sLong = new HashSet<Long>(Math.max(0, 2*_set64.size));
              for (int _i65 = 0; 
                   (_set64.size < 0) ? iprot.peekSet() : (_i65 < _set64.size); 
                   ++_i65)
              {
                long _elem66;
                _elem66 = iprot.readI64();
                this.sLong.add(_elem66);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SSTRING:
          if (__field.type == TType.SET) {
            {
              TSet _set67 = iprot.readSetBegin();
              this.sString = new HashSet<String>(Math.max(0, 2*_set67.size));
              for (int _i68 = 0; 
                   (_set67.size < 0) ? iprot.peekSet() : (_i68 < _set67.size); 
                   ++_i68)
              {
                String _elem69;
                _elem69 = iprot.readString();
                this.sString.add(_elem69);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SBYTE:
          if (__field.type == TType.SET) {
            {
              TSet _set70 = iprot.readSetBegin();
              this.sByte = new HashSet<Byte>(Math.max(0, 2*_set70.size));
              for (int _i71 = 0; 
                   (_set70.size < 0) ? iprot.peekSet() : (_i71 < _set70.size); 
                   ++_i71)
              {
                byte _elem72;
                _elem72 = iprot.readByte();
                this.sByte.add(_elem72);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MLISTLIST:
          if (__field.type == TType.MAP) {
            {
              TMap _map73 = iprot.readMapBegin();
              this.mListList = new HashMap<List<Integer>,List<Integer>>(Math.max(0, 2*_map73.size));
              for (int _i74 = 0; 
                   (_map73.size < 0) ? iprot.peekMap() : (_i74 < _map73.size); 
                   ++_i74)
              {
                List<Integer> _key75;
                List<Integer> _val76;
                {
                  TList _list77 = iprot.readListBegin();
                  _key75 = new ArrayList<Integer>(Math.max(0, _list77.size));
                  for (int _i78 = 0; 
                       (_list77.size < 0) ? iprot.peekList() : (_i78 < _list77.size); 
                       ++_i78)
                  {
                    int _elem79;
                    _elem79 = iprot.readI32();
                    _key75.add(_elem79);
                  }
                  iprot.readListEnd();
                }
                {
                  TList _list80 = iprot.readListBegin();
                  _val76 = new ArrayList<Integer>(Math.max(0, _list80.size));
                  for (int _i81 = 0; 
                       (_list80.size < 0) ? iprot.peekList() : (_i81 < _list80.size); 
                       ++_i81)
                  {
                    int _elem82;
                    _elem82 = iprot.readI32();
                    _val76.add(_elem82);
                  }
                  iprot.readListEnd();
                }
                this.mListList.put(_key75, _val76);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, __field.type);
          break;
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();


    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }

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

    oprot.writeStructBegin(STRUCT_DESC);
    oprot.writeFieldBegin(MY_INT_FIELD_FIELD_DESC);
    oprot.writeI64(this.MyIntField);
    oprot.writeFieldEnd();
    if (this.MyStringField != null) {
      oprot.writeFieldBegin(MY_STRING_FIELD_FIELD_DESC);
      oprot.writeString(this.MyStringField);
      oprot.writeFieldEnd();
    }
    if (this.MyDataField != null) {
      oprot.writeFieldBegin(MY_DATA_FIELD_FIELD_DESC);
      this.MyDataField.write(oprot);
      oprot.writeFieldEnd();
    }
    if (this.myEnum != null) {
      oprot.writeFieldBegin(MY_ENUM_FIELD_DESC);
      oprot.writeI32(this.myEnum == null ? 0 : this.myEnum.getValue());
      oprot.writeFieldEnd();
    }
    oprot.writeFieldBegin(MY_BOOL_FIELD_FIELD_DESC);
    oprot.writeBool(this.MyBoolField);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_BYTE_FIELD_FIELD_DESC);
    oprot.writeByte(this.MyByteField);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_SHORT_FIELD_FIELD_DESC);
    oprot.writeI16(this.MyShortField);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_LONG_FIELD_FIELD_DESC);
    oprot.writeI64(this.MyLongField);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_DOUBLE_FIELD_FIELD_DESC);
    oprot.writeDouble(this.MyDoubleField);
    oprot.writeFieldEnd();
    if (this.lDouble != null) {
      oprot.writeFieldBegin(L_DOUBLE_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.DOUBLE, this.lDouble.size()));
        for (double _iter83 : this.lDouble)        {
          oprot.writeDouble(_iter83);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lShort != null) {
      oprot.writeFieldBegin(L_SHORT_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.I16, this.lShort.size()));
        for (short _iter84 : this.lShort)        {
          oprot.writeI16(_iter84);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lInteger != null) {
      oprot.writeFieldBegin(L_INTEGER_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.I32, this.lInteger.size()));
        for (int _iter85 : this.lInteger)        {
          oprot.writeI32(_iter85);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lLong != null) {
      oprot.writeFieldBegin(L_LONG_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.I64, this.lLong.size()));
        for (long _iter86 : this.lLong)        {
          oprot.writeI64(_iter86);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lString != null) {
      oprot.writeFieldBegin(L_STRING_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.STRING, this.lString.size()));
        for (String _iter87 : this.lString)        {
          oprot.writeString(_iter87);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lBool != null) {
      oprot.writeFieldBegin(L_BOOL_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.BOOL, this.lBool.size()));
        for (boolean _iter88 : this.lBool)        {
          oprot.writeBool(_iter88);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.lByte != null) {
      oprot.writeFieldBegin(L_BYTE_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.BYTE, this.lByte.size()));
        for (byte _iter89 : this.lByte)        {
          oprot.writeByte(_iter89);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mShortString != null) {
      oprot.writeFieldBegin(M_SHORT_STRING_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I16, TType.STRING, this.mShortString.size()));
        for (Map.Entry<Short, String> _iter90 : this.mShortString.entrySet())        {
          oprot.writeI16(_iter90.getKey());
          oprot.writeString(_iter90.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mIntegerString != null) {
      oprot.writeFieldBegin(M_INTEGER_STRING_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, this.mIntegerString.size()));
        for (Map.Entry<Integer, String> _iter91 : this.mIntegerString.entrySet())        {
          oprot.writeI32(_iter91.getKey());
          oprot.writeString(_iter91.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mStringMyStruct != null) {
      oprot.writeFieldBegin(M_STRING_MY_STRUCT_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.STRING, TType.STRUCT, this.mStringMyStruct.size()));
        for (Map.Entry<String, MyStruct> _iter92 : this.mStringMyStruct.entrySet())        {
          oprot.writeString(_iter92.getKey());
          _iter92.getValue().write(oprot);
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mStringBool != null) {
      oprot.writeFieldBegin(M_STRING_BOOL_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.STRING, TType.BOOL, this.mStringBool.size()));
        for (Map.Entry<String, Boolean> _iter93 : this.mStringBool.entrySet())        {
          oprot.writeString(_iter93.getKey());
          oprot.writeBool(_iter93.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mIntegerInteger != null) {
      oprot.writeFieldBegin(M_INTEGER_INTEGER_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.I32, this.mIntegerInteger.size()));
        for (Map.Entry<Integer, Integer> _iter94 : this.mIntegerInteger.entrySet())        {
          oprot.writeI32(_iter94.getKey());
          oprot.writeI32(_iter94.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mIntegerBool != null) {
      oprot.writeFieldBegin(M_INTEGER_BOOL_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.BOOL, this.mIntegerBool.size()));
        for (Map.Entry<Integer, Boolean> _iter95 : this.mIntegerBool.entrySet())        {
          oprot.writeI32(_iter95.getKey());
          oprot.writeBool(_iter95.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.sShort != null) {
      oprot.writeFieldBegin(S_SHORT_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.I16, this.sShort.size()));
        for (short _iter96 : this.sShort)        {
          oprot.writeI16(_iter96);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.sMyStruct != null) {
      oprot.writeFieldBegin(S_MY_STRUCT_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.STRUCT, this.sMyStruct.size()));
        for (MyStruct _iter97 : this.sMyStruct)        {
          _iter97.write(oprot);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.sLong != null) {
      oprot.writeFieldBegin(S_LONG_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.I64, this.sLong.size()));
        for (long _iter98 : this.sLong)        {
          oprot.writeI64(_iter98);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.sString != null) {
      oprot.writeFieldBegin(S_STRING_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.STRING, this.sString.size()));
        for (String _iter99 : this.sString)        {
          oprot.writeString(_iter99);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.sByte != null) {
      oprot.writeFieldBegin(S_BYTE_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.BYTE, this.sByte.size()));
        for (byte _iter100 : this.sByte)        {
          oprot.writeByte(_iter100);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mListList != null) {
      oprot.writeFieldBegin(M_LIST_LIST_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.LIST, TType.LIST, this.mListList.size()));
        for (Map.Entry<List<Integer>, List<Integer>> _iter101 : this.mListList.entrySet())        {
          {
            oprot.writeListBegin(new TList(TType.I32, _iter101.getKey().size()));
            for (int _iter102 : _iter101.getKey())            {
              oprot.writeI32(_iter102);
            }
            oprot.writeListEnd();
          }
          {
            oprot.writeListBegin(new TList(TType.I32, _iter101.getValue().size()));
            for (int _iter103 : _iter101.getValue())            {
              oprot.writeI32(_iter103);
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    oprot.writeFieldStop();
    oprot.writeStructEnd();
  }

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

  @Override
  public String toString(int indent, boolean prettyPrint) {
    String indentStr = prettyPrint ? TBaseHelper.getIndentedString(indent) : "";
    String newLine = prettyPrint ? "\n" : "";
    String space = prettyPrint ? " " : "";
    StringBuilder sb = new StringBuilder("MyStruct");
    sb.append(space);
    sb.append("(");
    sb.append(newLine);
    boolean first = true;

    sb.append(indentStr);
    sb.append("MyIntField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyIntField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyStringField");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyStringField() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMyStringField(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyDataField");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyDataField() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMyDataField(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myEnum");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyEnum() == null) {
      sb.append("null");
    } else {
      String myEnum_name = this.getMyEnum() == null ? "null" : this.getMyEnum().name();
      if (myEnum_name != null) {
        sb.append(myEnum_name);
        sb.append(" (");
      }
      sb.append(this.getMyEnum());
      if (myEnum_name != null) {
        sb.append(")");
      }
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyBoolField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.isMyBoolField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyByteField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyByteField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyShortField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyShortField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyLongField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyLongField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("MyDoubleField");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyDoubleField(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lDouble");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLDouble() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLDouble(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lShort");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLShort() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLShort(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lInteger");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLInteger() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLInteger(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lString");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLString() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLString(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lBool");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLBool() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLBool(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("lByte");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getLByte() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getLByte(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mShortString");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMShortString() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMShortString(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mIntegerString");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMIntegerString() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMIntegerString(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mStringMyStruct");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMStringMyStruct() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMStringMyStruct(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mStringBool");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMStringBool() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMStringBool(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mIntegerInteger");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMIntegerInteger() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMIntegerInteger(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mIntegerBool");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMIntegerBool() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMIntegerBool(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("sShort");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSShort() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSShort(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("sMyStruct");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSMyStruct() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSMyStruct(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("sLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("sString");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSString() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSString(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("sByte");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSByte() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSByte(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mListList");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMListList() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMListList(), indent + 1, prettyPrint));
    }
    first = false;
    sb.append(newLine + TBaseHelper.reduceIndent(indentStr));
    sb.append(")");
    return sb.toString();
  }

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

}