/**
 * 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 defaultStruct implements TBase, java.io.Serializable, Cloneable {
  private static final TStruct STRUCT_DESC = new TStruct("defaultStruct");
  private static final TField MY_LONG_DFSET_FIELD_DESC = new TField("myLongDFset", TType.I64, (short)1);
  private static final TField MY_LONG_DF_FIELD_DESC = new TField("myLongDF", TType.I64, (short)2);
  private static final TField PORT_DFSET_FIELD_DESC = new TField("portDFset", TType.I32, (short)3);
  private static final TField PORT_NUM_FIELD_DESC = new TField("portNum", TType.I32, (short)4);
  private static final TField MY_BINARY_DFSET_FIELD_DESC = new TField("myBinaryDFset", TType.STRING, (short)5);
  private static final TField MY_BINARY_FIELD_DESC = new TField("myBinary", TType.STRING, (short)6);
  private static final TField MY_BYTE_DFSET_FIELD_DESC = new TField("myByteDFSet", TType.BYTE, (short)7);
  private static final TField MY_BYTE_FIELD_DESC = new TField("myByte", TType.BYTE, (short)8);
  private static final TField MY_DOUBLE_DFSET_FIELD_DESC = new TField("myDoubleDFset", TType.DOUBLE, (short)9);
  private static final TField MY_DOUBLE_DFZERO_FIELD_DESC = new TField("myDoubleDFZero", TType.DOUBLE, (short)10);
  private static final TField MY_DOUBLE_FIELD_DESC = new TField("myDouble", TType.DOUBLE, (short)12);
  private static final TField FIELD3_FIELD_DESC = new TField("field3", TType.MAP, (short)13);
  private static final TField MY_LIST_FIELD_DESC = new TField("myList", TType.LIST, (short)14);
  private static final TField MY_SET_FIELD_DESC = new TField("mySet", TType.SET, (short)15);
  private static final TField SIMPLE_STRUCT_FIELD_DESC = new TField("simpleStruct", TType.STRUCT, (short)16);
  private static final TField LIST_STRUCT_DFSET_FIELD_DESC = new TField("listStructDFset", TType.LIST, (short)17);
  private static final TField MY_UNION_FIELD_DESC = new TField("myUnion", TType.STRUCT, (short)18);
  private static final TField LIST_UNION_DFSET_FIELD_DESC = new TField("listUnionDFset", TType.LIST, (short)19);
  private static final TField MAP_NESTLIST_STRUCT_DF_SET_FIELD_DESC = new TField("mapNestlistStructDfSet", TType.MAP, (short)20);
  private static final TField MAP_JAVA_TYPE_DFSET_FIELD_DESC = new TField("mapJavaTypeDFset", TType.MAP, (short)21);
  private static final TField EMPTY_MAP_FIELD_DESC = new TField("emptyMap", TType.MAP, (short)22);
  private static final TField ENUM_MAP_DFSET_FIELD_DESC = new TField("enumMapDFset", TType.MAP, (short)23);

  public long myLongDFset;
  public long myLongDF;
  public int portDFset;
  public int portNum;
  public byte[] myBinaryDFset;
  public byte[] myBinary;
  public byte myByteDFSet;
  public byte myByte;
  public double myDoubleDFset;
  public double myDoubleDFZero;
  public double myDouble;
  public Map<Integer,String> field3;
  public List<MyEnum> myList;
  public Set<String> mySet;
  public SimpleStruct simpleStruct;
  public List<SimpleStruct> listStructDFset;
  public MyUnion myUnion;
  public List<MyUnion> listUnionDFset;
  public Map<Integer,List<SimpleStruct>> mapNestlistStructDfSet;
  public Map<Long,String> mapJavaTypeDFset;
  public Map<Long,Integer> emptyMap;
  public Map<String,Map<Integer,MyEnum>> enumMapDFset;
  public static final int MYLONGDFSET = 1;
  public static final int MYLONGDF = 2;
  public static final int PORTDFSET = 3;
  public static final int PORTNUM = 4;
  public static final int MYBINARYDFSET = 5;
  public static final int MYBINARY = 6;
  public static final int MYBYTEDFSET = 7;
  public static final int MYBYTE = 8;
  public static final int MYDOUBLEDFSET = 9;
  public static final int MYDOUBLEDFZERO = 10;
  public static final int MYDOUBLE = 12;
  public static final int FIELD3 = 13;
  public static final int MYLIST = 14;
  public static final int MYSET = 15;
  public static final int SIMPLESTRUCT = 16;
  public static final int LISTSTRUCTDFSET = 17;
  public static final int MYUNION = 18;
  public static final int LISTUNIONDFSET = 19;
  public static final int MAPNESTLISTSTRUCTDFSET = 20;
  public static final int MAPJAVATYPEDFSET = 21;
  public static final int EMPTYMAP = 22;
  public static final int ENUMMAPDFSET = 23;

  // isset id assignments
  private static final int __MYLONGDFSET_ISSET_ID = 0;
  private static final int __MYLONGDF_ISSET_ID = 1;
  private static final int __PORTDFSET_ISSET_ID = 2;
  private static final int __PORTNUM_ISSET_ID = 3;
  private static final int __MYBYTEDFSET_ISSET_ID = 4;
  private static final int __MYBYTE_ISSET_ID = 5;
  private static final int __MYDOUBLEDFSET_ISSET_ID = 6;
  private static final int __MYDOUBLEDFZERO_ISSET_ID = 7;
  private static final int __MYDOUBLE_ISSET_ID = 8;
  private BitSet __isset_bit_vector = new BitSet(9);

  public static final Map<Integer, FieldMetaData> metaDataMap;

  static {
    Map<Integer, FieldMetaData> tmpMetaDataMap = new HashMap<Integer, FieldMetaData>();
    tmpMetaDataMap.put(MYLONGDFSET, new FieldMetaData("myLongDFset", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I64)));
    tmpMetaDataMap.put(MYLONGDF, new FieldMetaData("myLongDF", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I64)));
    tmpMetaDataMap.put(PORTDFSET, new FieldMetaData("portDFset", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I32)));
    tmpMetaDataMap.put(PORTNUM, new FieldMetaData("portNum", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.I32)));
    tmpMetaDataMap.put(MYBINARYDFSET, new FieldMetaData("myBinaryDFset", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.STRING)));
    tmpMetaDataMap.put(MYBINARY, new FieldMetaData("myBinary", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.STRING)));
    tmpMetaDataMap.put(MYBYTEDFSET, new FieldMetaData("myByteDFSet", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.BYTE)));
    tmpMetaDataMap.put(MYBYTE, new FieldMetaData("myByte", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.BYTE)));
    tmpMetaDataMap.put(MYDOUBLEDFSET, new FieldMetaData("myDoubleDFset", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.DOUBLE)));
    tmpMetaDataMap.put(MYDOUBLEDFZERO, new FieldMetaData("myDoubleDFZero", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.DOUBLE)));
    tmpMetaDataMap.put(MYDOUBLE, new FieldMetaData("myDouble", TFieldRequirementType.DEFAULT, 
        new FieldValueMetaData(TType.DOUBLE)));
    tmpMetaDataMap.put(FIELD3, new FieldMetaData("field3", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(MYLIST, new FieldMetaData("myList", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(MYSET, new FieldMetaData("mySet", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(SIMPLESTRUCT, new FieldMetaData("simpleStruct", TFieldRequirementType.DEFAULT, 
        new StructMetaData(TType.STRUCT, SimpleStruct.class)));
    tmpMetaDataMap.put(LISTSTRUCTDFSET, new FieldMetaData("listStructDFset", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new StructMetaData(TType.STRUCT, SimpleStruct.class))));
    tmpMetaDataMap.put(MYUNION, new FieldMetaData("myUnion", TFieldRequirementType.DEFAULT, 
        new StructMetaData(TType.STRUCT, MyUnion.class)));
    tmpMetaDataMap.put(LISTUNIONDFSET, new FieldMetaData("listUnionDFset", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new StructMetaData(TType.STRUCT, MyUnion.class))));
    tmpMetaDataMap.put(MAPNESTLISTSTRUCTDFSET, new FieldMetaData("mapNestlistStructDfSet", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new ListMetaData(TType.LIST, 
                new StructMetaData(TType.STRUCT, SimpleStruct.class)))));
    tmpMetaDataMap.put(MAPJAVATYPEDFSET, new FieldMetaData("mapJavaTypeDFset", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I64), 
            new FieldValueMetaData(TType.STRING))));
    tmpMetaDataMap.put(EMPTYMAP, new FieldMetaData("emptyMap", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I64), 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(ENUMMAPDFSET, new FieldMetaData("enumMapDFset", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.STRING), 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.I32), 
                new FieldValueMetaData(TType.I32)))));
    metaDataMap = Collections.unmodifiableMap(tmpMetaDataMap);
  }

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

  public defaultStruct() {
    this.myLongDFset = 10L;

    this.portDFset = 3456;

    this.myBinaryDFset = "abc".getBytes();

    this.myByteDFSet = (byte)17;

    this.myDoubleDFset = 99.7678;

    this.myDoubleDFZero = 0;

    this.field3 = new HashMap<Integer,String>();
    this.field3.put(15, "a_value");
    this.field3.put(2, "b_value");

    this.myList = new ArrayList<MyEnum>();
    this.myList.add(MyEnum.MyValue1);
    this.myList.add(MyEnum.MyValue1);
    this.myList.add(MyEnum.MyValue2);

    this.mySet = new HashSet<String>();
    this.mySet.add("house");
    this.mySet.add("car");
    this.mySet.add("dog");

    this.simpleStruct = new SimpleStruct();
    this.simpleStruct.setAge(40L);
    this.simpleStruct.setName("John");

    this.listStructDFset = new ArrayList<SimpleStruct>();
    SimpleStruct tmp104 = new SimpleStruct();
    tmp104.setAge(40L);
    tmp104.setName("IronMan");

    this.listStructDFset.add(tmp104);
    SimpleStruct tmp105 = new SimpleStruct();
    tmp105.setAge(999L);
    tmp105.setName("Thanos");

    this.listStructDFset.add(tmp105);

    this.myUnion = new MyUnion();
    this.myUnion.setMyEnum(MyEnum.MyValue2);

    this.listUnionDFset = new ArrayList<MyUnion>();
    MyUnion tmp106 = new MyUnion();
    tmp106.setMyEnum(MyEnum.MyValue2);

    this.listUnionDFset.add(tmp106);
    MyUnion tmp107 = new MyUnion();
    tmp107.setIntValue(123);

    this.listUnionDFset.add(tmp107);

    this.mapNestlistStructDfSet = new HashMap<Integer,List<SimpleStruct>>();
    List<SimpleStruct> tmp108 = new ArrayList<SimpleStruct>();
    SimpleStruct tmp109 = new SimpleStruct();
    tmp109.setAge(40L);
    tmp109.setName("IronMan");

    tmp108.add(tmp109);
    SimpleStruct tmp110 = new SimpleStruct();
    tmp110.setAge(999L);
    tmp110.setName("Thanos");

    tmp108.add(tmp110);

    this.mapNestlistStructDfSet.put(1, tmp108);
    List<SimpleStruct> tmp111 = new ArrayList<SimpleStruct>();
    SimpleStruct tmp112 = new SimpleStruct();
    tmp112.setAge(28L);
    tmp112.setName("BatMan");

    tmp111.add(tmp112);
    SimpleStruct tmp113 = new SimpleStruct();
    tmp113.setAge(12L);
    tmp113.setName("Robin");

    tmp111.add(tmp113);

    this.mapNestlistStructDfSet.put(2, tmp111);
    List<SimpleStruct> tmp114 = new ArrayList<SimpleStruct>();
    SimpleStruct tmp115 = new SimpleStruct();
    tmp115.setAge(12L);
    tmp115.setName("RatMan");

    tmp114.add(tmp115);
    SimpleStruct tmp116 = new SimpleStruct();
    tmp116.setAge(6L);
    tmp116.setName("Catman");

    tmp114.add(tmp116);

    this.mapNestlistStructDfSet.put(5, tmp114);

    this.mapJavaTypeDFset = new HashMap<Long,String>();
    this.mapJavaTypeDFset.put(15L, "a_value");
    this.mapJavaTypeDFset.put(2L, "b_value");

    this.emptyMap = new HashMap<Long,Integer>();

    this.enumMapDFset = new HashMap<String,Map<Integer,MyEnum>>();
    Map<Integer,MyEnum> tmp117 = new HashMap<Integer,MyEnum>();
    tmp117.put(16, MyEnum.MyValue1);
    tmp117.put(144, MyEnum.MyValue1);

    this.enumMapDFset.put("SANDY BRIDGE", tmp117);
    Map<Integer,MyEnum> tmp118 = new HashMap<Integer,MyEnum>();
    tmp118.put(32, MyEnum.MyValue2);
    tmp118.put(144, MyEnum.MyValue2);

    this.enumMapDFset.put("IVY BRIDGE", tmp118);
    Map<Integer,MyEnum> tmp119 = new HashMap<Integer,MyEnum>();
    tmp119.put(32, MyEnum.MyValue3);
    tmp119.put(128, MyEnum.MyValue3);
    tmp119.put(256, MyEnum.MyValue3);

    this.enumMapDFset.put("HASWELL", tmp119);

  }

  public defaultStruct(
      long myLongDFset,
      long myLongDF,
      int portDFset,
      int portNum,
      byte[] myBinaryDFset,
      byte[] myBinary,
      byte myByteDFSet,
      byte myByte,
      double myDoubleDFset,
      double myDoubleDFZero,
      double myDouble,
      Map<Integer,String> field3,
      List<MyEnum> myList,
      Set<String> mySet,
      SimpleStruct simpleStruct,
      List<SimpleStruct> listStructDFset,
      MyUnion myUnion,
      List<MyUnion> listUnionDFset,
      Map<Integer,List<SimpleStruct>> mapNestlistStructDfSet,
      Map<Long,String> mapJavaTypeDFset,
      Map<Long,Integer> emptyMap,
      Map<String,Map<Integer,MyEnum>> enumMapDFset) {
    this();
    this.myLongDFset = myLongDFset;
    setMyLongDFsetIsSet(true);
    this.myLongDF = myLongDF;
    setMyLongDFIsSet(true);
    this.portDFset = portDFset;
    setPortDFsetIsSet(true);
    this.portNum = portNum;
    setPortNumIsSet(true);
    this.myBinaryDFset = myBinaryDFset;
    this.myBinary = myBinary;
    this.myByteDFSet = myByteDFSet;
    setMyByteDFSetIsSet(true);
    this.myByte = myByte;
    setMyByteIsSet(true);
    this.myDoubleDFset = myDoubleDFset;
    setMyDoubleDFsetIsSet(true);
    this.myDoubleDFZero = myDoubleDFZero;
    setMyDoubleDFZeroIsSet(true);
    this.myDouble = myDouble;
    setMyDoubleIsSet(true);
    this.field3 = field3;
    this.myList = myList;
    this.mySet = mySet;
    this.simpleStruct = simpleStruct;
    this.listStructDFset = listStructDFset;
    this.myUnion = myUnion;
    this.listUnionDFset = listUnionDFset;
    this.mapNestlistStructDfSet = mapNestlistStructDfSet;
    this.mapJavaTypeDFset = mapJavaTypeDFset;
    this.emptyMap = emptyMap;
    this.enumMapDFset = enumMapDFset;
  }

  public static class Builder {
    private long myLongDFset;
    private long myLongDF;
    private int portDFset;
    private int portNum;
    private byte[] myBinaryDFset;
    private byte[] myBinary;
    private byte myByteDFSet;
    private byte myByte;
    private double myDoubleDFset;
    private double myDoubleDFZero;
    private double myDouble;
    private Map<Integer,String> field3;
    private List<MyEnum> myList;
    private Set<String> mySet;
    private SimpleStruct simpleStruct;
    private List<SimpleStruct> listStructDFset;
    private MyUnion myUnion;
    private List<MyUnion> listUnionDFset;
    private Map<Integer,List<SimpleStruct>> mapNestlistStructDfSet;
    private Map<Long,String> mapJavaTypeDFset;
    private Map<Long,Integer> emptyMap;
    private Map<String,Map<Integer,MyEnum>> enumMapDFset;

    BitSet __optional_isset = new BitSet(9);

    public Builder() {
    }

    public Builder setMyLongDFset(final long myLongDFset) {
      this.myLongDFset = myLongDFset;
      __optional_isset.set(__MYLONGDFSET_ISSET_ID, true);
      return this;
    }

    public Builder setMyLongDF(final long myLongDF) {
      this.myLongDF = myLongDF;
      __optional_isset.set(__MYLONGDF_ISSET_ID, true);
      return this;
    }

    public Builder setPortDFset(final int portDFset) {
      this.portDFset = portDFset;
      __optional_isset.set(__PORTDFSET_ISSET_ID, true);
      return this;
    }

    public Builder setPortNum(final int portNum) {
      this.portNum = portNum;
      __optional_isset.set(__PORTNUM_ISSET_ID, true);
      return this;
    }

    public Builder setMyBinaryDFset(final byte[] myBinaryDFset) {
      this.myBinaryDFset = myBinaryDFset;
      return this;
    }

    public Builder setMyBinary(final byte[] myBinary) {
      this.myBinary = myBinary;
      return this;
    }

    public Builder setMyByteDFSet(final byte myByteDFSet) {
      this.myByteDFSet = myByteDFSet;
      __optional_isset.set(__MYBYTEDFSET_ISSET_ID, true);
      return this;
    }

    public Builder setMyByte(final byte myByte) {
      this.myByte = myByte;
      __optional_isset.set(__MYBYTE_ISSET_ID, true);
      return this;
    }

    public Builder setMyDoubleDFset(final double myDoubleDFset) {
      this.myDoubleDFset = myDoubleDFset;
      __optional_isset.set(__MYDOUBLEDFSET_ISSET_ID, true);
      return this;
    }

    public Builder setMyDoubleDFZero(final double myDoubleDFZero) {
      this.myDoubleDFZero = myDoubleDFZero;
      __optional_isset.set(__MYDOUBLEDFZERO_ISSET_ID, true);
      return this;
    }

    public Builder setMyDouble(final double myDouble) {
      this.myDouble = myDouble;
      __optional_isset.set(__MYDOUBLE_ISSET_ID, true);
      return this;
    }

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

    public Builder setMyList(final List<MyEnum> myList) {
      this.myList = myList;
      return this;
    }

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

    public Builder setSimpleStruct(final SimpleStruct simpleStruct) {
      this.simpleStruct = simpleStruct;
      return this;
    }

    public Builder setListStructDFset(final List<SimpleStruct> listStructDFset) {
      this.listStructDFset = listStructDFset;
      return this;
    }

    public Builder setMyUnion(final MyUnion myUnion) {
      this.myUnion = myUnion;
      return this;
    }

    public Builder setListUnionDFset(final List<MyUnion> listUnionDFset) {
      this.listUnionDFset = listUnionDFset;
      return this;
    }

    public Builder setMapNestlistStructDfSet(final Map<Integer,List<SimpleStruct>> mapNestlistStructDfSet) {
      this.mapNestlistStructDfSet = mapNestlistStructDfSet;
      return this;
    }

    public Builder setMapJavaTypeDFset(final Map<Long,String> mapJavaTypeDFset) {
      this.mapJavaTypeDFset = mapJavaTypeDFset;
      return this;
    }

    public Builder setEmptyMap(final Map<Long,Integer> emptyMap) {
      this.emptyMap = emptyMap;
      return this;
    }

    public Builder setEnumMapDFset(final Map<String,Map<Integer,MyEnum>> enumMapDFset) {
      this.enumMapDFset = enumMapDFset;
      return this;
    }

    public defaultStruct build() {
      defaultStruct result = new defaultStruct();
      if (__optional_isset.get(__MYLONGDFSET_ISSET_ID)) {
        result.setMyLongDFset(this.myLongDFset);
      }
      if (__optional_isset.get(__MYLONGDF_ISSET_ID)) {
        result.setMyLongDF(this.myLongDF);
      }
      if (__optional_isset.get(__PORTDFSET_ISSET_ID)) {
        result.setPortDFset(this.portDFset);
      }
      if (__optional_isset.get(__PORTNUM_ISSET_ID)) {
        result.setPortNum(this.portNum);
      }
      result.setMyBinaryDFset(this.myBinaryDFset);
      result.setMyBinary(this.myBinary);
      if (__optional_isset.get(__MYBYTEDFSET_ISSET_ID)) {
        result.setMyByteDFSet(this.myByteDFSet);
      }
      if (__optional_isset.get(__MYBYTE_ISSET_ID)) {
        result.setMyByte(this.myByte);
      }
      if (__optional_isset.get(__MYDOUBLEDFSET_ISSET_ID)) {
        result.setMyDoubleDFset(this.myDoubleDFset);
      }
      if (__optional_isset.get(__MYDOUBLEDFZERO_ISSET_ID)) {
        result.setMyDoubleDFZero(this.myDoubleDFZero);
      }
      if (__optional_isset.get(__MYDOUBLE_ISSET_ID)) {
        result.setMyDouble(this.myDouble);
      }
      result.setField3(this.field3);
      result.setMyList(this.myList);
      result.setMySet(this.mySet);
      result.setSimpleStruct(this.simpleStruct);
      result.setListStructDFset(this.listStructDFset);
      result.setMyUnion(this.myUnion);
      result.setListUnionDFset(this.listUnionDFset);
      result.setMapNestlistStructDfSet(this.mapNestlistStructDfSet);
      result.setMapJavaTypeDFset(this.mapJavaTypeDFset);
      result.setEmptyMap(this.emptyMap);
      result.setEnumMapDFset(this.enumMapDFset);
      return result;
    }
  }

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

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public defaultStruct(defaultStruct other) {
    __isset_bit_vector.clear();
    __isset_bit_vector.or(other.__isset_bit_vector);
    this.myLongDFset = TBaseHelper.deepCopy(other.myLongDFset);
    this.myLongDF = TBaseHelper.deepCopy(other.myLongDF);
    this.portDFset = TBaseHelper.deepCopy(other.portDFset);
    this.portNum = TBaseHelper.deepCopy(other.portNum);
    if (other.isSetMyBinaryDFset()) {
      this.myBinaryDFset = TBaseHelper.deepCopy(other.myBinaryDFset);
    }
    if (other.isSetMyBinary()) {
      this.myBinary = TBaseHelper.deepCopy(other.myBinary);
    }
    this.myByteDFSet = TBaseHelper.deepCopy(other.myByteDFSet);
    this.myByte = TBaseHelper.deepCopy(other.myByte);
    this.myDoubleDFset = TBaseHelper.deepCopy(other.myDoubleDFset);
    this.myDoubleDFZero = TBaseHelper.deepCopy(other.myDoubleDFZero);
    this.myDouble = TBaseHelper.deepCopy(other.myDouble);
    if (other.isSetField3()) {
      this.field3 = TBaseHelper.deepCopy(other.field3);
    }
    if (other.isSetMyList()) {
      this.myList = TBaseHelper.deepCopy(other.myList);
    }
    if (other.isSetMySet()) {
      this.mySet = TBaseHelper.deepCopy(other.mySet);
    }
    if (other.isSetSimpleStruct()) {
      this.simpleStruct = TBaseHelper.deepCopy(other.simpleStruct);
    }
    if (other.isSetListStructDFset()) {
      this.listStructDFset = TBaseHelper.deepCopy(other.listStructDFset);
    }
    if (other.isSetMyUnion()) {
      this.myUnion = TBaseHelper.deepCopy(other.myUnion);
    }
    if (other.isSetListUnionDFset()) {
      this.listUnionDFset = TBaseHelper.deepCopy(other.listUnionDFset);
    }
    if (other.isSetMapNestlistStructDfSet()) {
      this.mapNestlistStructDfSet = TBaseHelper.deepCopy(other.mapNestlistStructDfSet);
    }
    if (other.isSetMapJavaTypeDFset()) {
      this.mapJavaTypeDFset = TBaseHelper.deepCopy(other.mapJavaTypeDFset);
    }
    if (other.isSetEmptyMap()) {
      this.emptyMap = TBaseHelper.deepCopy(other.emptyMap);
    }
    if (other.isSetEnumMapDFset()) {
      this.enumMapDFset = TBaseHelper.deepCopy(other.enumMapDFset);
    }
  }

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

  public long getMyLongDFset() {
    return this.myLongDFset;
  }

  public defaultStruct setMyLongDFset(long myLongDFset) {
    this.myLongDFset = myLongDFset;
    setMyLongDFsetIsSet(true);
    return this;
  }

  public void unsetMyLongDFset() {
    __isset_bit_vector.clear(__MYLONGDFSET_ISSET_ID);
  }

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

  public void setMyLongDFsetIsSet(boolean __value) {
    __isset_bit_vector.set(__MYLONGDFSET_ISSET_ID, __value);
  }

  public long getMyLongDF() {
    return this.myLongDF;
  }

  public defaultStruct setMyLongDF(long myLongDF) {
    this.myLongDF = myLongDF;
    setMyLongDFIsSet(true);
    return this;
  }

  public void unsetMyLongDF() {
    __isset_bit_vector.clear(__MYLONGDF_ISSET_ID);
  }

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

  public void setMyLongDFIsSet(boolean __value) {
    __isset_bit_vector.set(__MYLONGDF_ISSET_ID, __value);
  }

  public int getPortDFset() {
    return this.portDFset;
  }

  public defaultStruct setPortDFset(int portDFset) {
    this.portDFset = portDFset;
    setPortDFsetIsSet(true);
    return this;
  }

  public void unsetPortDFset() {
    __isset_bit_vector.clear(__PORTDFSET_ISSET_ID);
  }

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

  public void setPortDFsetIsSet(boolean __value) {
    __isset_bit_vector.set(__PORTDFSET_ISSET_ID, __value);
  }

  public int getPortNum() {
    return this.portNum;
  }

  public defaultStruct setPortNum(int portNum) {
    this.portNum = portNum;
    setPortNumIsSet(true);
    return this;
  }

  public void unsetPortNum() {
    __isset_bit_vector.clear(__PORTNUM_ISSET_ID);
  }

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

  public void setPortNumIsSet(boolean __value) {
    __isset_bit_vector.set(__PORTNUM_ISSET_ID, __value);
  }

  public byte[] getMyBinaryDFset() {
    return this.myBinaryDFset;
  }

  public defaultStruct setMyBinaryDFset(byte[] myBinaryDFset) {
    this.myBinaryDFset = myBinaryDFset;
    return this;
  }

  public void unsetMyBinaryDFset() {
    this.myBinaryDFset = null;
  }

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

  public void setMyBinaryDFsetIsSet(boolean __value) {
    if (!__value) {
      this.myBinaryDFset = null;
    }
  }

  public byte[] getMyBinary() {
    return this.myBinary;
  }

  public defaultStruct setMyBinary(byte[] myBinary) {
    this.myBinary = myBinary;
    return this;
  }

  public void unsetMyBinary() {
    this.myBinary = null;
  }

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

  public void setMyBinaryIsSet(boolean __value) {
    if (!__value) {
      this.myBinary = null;
    }
  }

  public byte getMyByteDFSet() {
    return this.myByteDFSet;
  }

  public defaultStruct setMyByteDFSet(byte myByteDFSet) {
    this.myByteDFSet = myByteDFSet;
    setMyByteDFSetIsSet(true);
    return this;
  }

  public void unsetMyByteDFSet() {
    __isset_bit_vector.clear(__MYBYTEDFSET_ISSET_ID);
  }

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

  public void setMyByteDFSetIsSet(boolean __value) {
    __isset_bit_vector.set(__MYBYTEDFSET_ISSET_ID, __value);
  }

  public byte getMyByte() {
    return this.myByte;
  }

  public defaultStruct setMyByte(byte myByte) {
    this.myByte = myByte;
    setMyByteIsSet(true);
    return this;
  }

  public void unsetMyByte() {
    __isset_bit_vector.clear(__MYBYTE_ISSET_ID);
  }

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

  public void setMyByteIsSet(boolean __value) {
    __isset_bit_vector.set(__MYBYTE_ISSET_ID, __value);
  }

  public double getMyDoubleDFset() {
    return this.myDoubleDFset;
  }

  public defaultStruct setMyDoubleDFset(double myDoubleDFset) {
    this.myDoubleDFset = myDoubleDFset;
    setMyDoubleDFsetIsSet(true);
    return this;
  }

  public void unsetMyDoubleDFset() {
    __isset_bit_vector.clear(__MYDOUBLEDFSET_ISSET_ID);
  }

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

  public void setMyDoubleDFsetIsSet(boolean __value) {
    __isset_bit_vector.set(__MYDOUBLEDFSET_ISSET_ID, __value);
  }

  public double getMyDoubleDFZero() {
    return this.myDoubleDFZero;
  }

  public defaultStruct setMyDoubleDFZero(double myDoubleDFZero) {
    this.myDoubleDFZero = myDoubleDFZero;
    setMyDoubleDFZeroIsSet(true);
    return this;
  }

  public void unsetMyDoubleDFZero() {
    __isset_bit_vector.clear(__MYDOUBLEDFZERO_ISSET_ID);
  }

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

  public void setMyDoubleDFZeroIsSet(boolean __value) {
    __isset_bit_vector.set(__MYDOUBLEDFZERO_ISSET_ID, __value);
  }

  public double getMyDouble() {
    return this.myDouble;
  }

  public defaultStruct setMyDouble(double myDouble) {
    this.myDouble = myDouble;
    setMyDoubleIsSet(true);
    return this;
  }

  public void unsetMyDouble() {
    __isset_bit_vector.clear(__MYDOUBLE_ISSET_ID);
  }

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

  public void setMyDoubleIsSet(boolean __value) {
    __isset_bit_vector.set(__MYDOUBLE_ISSET_ID, __value);
  }

  public Map<Integer,String> getField3() {
    return this.field3;
  }

  public defaultStruct setField3(Map<Integer,String> field3) {
    this.field3 = field3;
    return this;
  }

  public void unsetField3() {
    this.field3 = null;
  }

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

  public void setField3IsSet(boolean __value) {
    if (!__value) {
      this.field3 = null;
    }
  }

  public List<MyEnum> getMyList() {
    return this.myList;
  }

  public defaultStruct setMyList(List<MyEnum> myList) {
    this.myList = myList;
    return this;
  }

  public void unsetMyList() {
    this.myList = null;
  }

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

  public void setMyListIsSet(boolean __value) {
    if (!__value) {
      this.myList = null;
    }
  }

  public Set<String> getMySet() {
    return this.mySet;
  }

  public defaultStruct setMySet(Set<String> mySet) {
    this.mySet = mySet;
    return this;
  }

  public void unsetMySet() {
    this.mySet = null;
  }

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

  public void setMySetIsSet(boolean __value) {
    if (!__value) {
      this.mySet = null;
    }
  }

  public SimpleStruct getSimpleStruct() {
    return this.simpleStruct;
  }

  public defaultStruct setSimpleStruct(SimpleStruct simpleStruct) {
    this.simpleStruct = simpleStruct;
    return this;
  }

  public void unsetSimpleStruct() {
    this.simpleStruct = null;
  }

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

  public void setSimpleStructIsSet(boolean __value) {
    if (!__value) {
      this.simpleStruct = null;
    }
  }

  public List<SimpleStruct> getListStructDFset() {
    return this.listStructDFset;
  }

  public defaultStruct setListStructDFset(List<SimpleStruct> listStructDFset) {
    this.listStructDFset = listStructDFset;
    return this;
  }

  public void unsetListStructDFset() {
    this.listStructDFset = null;
  }

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

  public void setListStructDFsetIsSet(boolean __value) {
    if (!__value) {
      this.listStructDFset = null;
    }
  }

  public MyUnion getMyUnion() {
    return this.myUnion;
  }

  public defaultStruct setMyUnion(MyUnion myUnion) {
    this.myUnion = myUnion;
    return this;
  }

  public void unsetMyUnion() {
    this.myUnion = null;
  }

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

  public void setMyUnionIsSet(boolean __value) {
    if (!__value) {
      this.myUnion = null;
    }
  }

  public List<MyUnion> getListUnionDFset() {
    return this.listUnionDFset;
  }

  public defaultStruct setListUnionDFset(List<MyUnion> listUnionDFset) {
    this.listUnionDFset = listUnionDFset;
    return this;
  }

  public void unsetListUnionDFset() {
    this.listUnionDFset = null;
  }

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

  public void setListUnionDFsetIsSet(boolean __value) {
    if (!__value) {
      this.listUnionDFset = null;
    }
  }

  public Map<Integer,List<SimpleStruct>> getMapNestlistStructDfSet() {
    return this.mapNestlistStructDfSet;
  }

  public defaultStruct setMapNestlistStructDfSet(Map<Integer,List<SimpleStruct>> mapNestlistStructDfSet) {
    this.mapNestlistStructDfSet = mapNestlistStructDfSet;
    return this;
  }

  public void unsetMapNestlistStructDfSet() {
    this.mapNestlistStructDfSet = null;
  }

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

  public void setMapNestlistStructDfSetIsSet(boolean __value) {
    if (!__value) {
      this.mapNestlistStructDfSet = null;
    }
  }

  public Map<Long,String> getMapJavaTypeDFset() {
    return this.mapJavaTypeDFset;
  }

  public defaultStruct setMapJavaTypeDFset(Map<Long,String> mapJavaTypeDFset) {
    this.mapJavaTypeDFset = mapJavaTypeDFset;
    return this;
  }

  public void unsetMapJavaTypeDFset() {
    this.mapJavaTypeDFset = null;
  }

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

  public void setMapJavaTypeDFsetIsSet(boolean __value) {
    if (!__value) {
      this.mapJavaTypeDFset = null;
    }
  }

  public Map<Long,Integer> getEmptyMap() {
    return this.emptyMap;
  }

  public defaultStruct setEmptyMap(Map<Long,Integer> emptyMap) {
    this.emptyMap = emptyMap;
    return this;
  }

  public void unsetEmptyMap() {
    this.emptyMap = null;
  }

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

  public void setEmptyMapIsSet(boolean __value) {
    if (!__value) {
      this.emptyMap = null;
    }
  }

  public Map<String,Map<Integer,MyEnum>> getEnumMapDFset() {
    return this.enumMapDFset;
  }

  public defaultStruct setEnumMapDFset(Map<String,Map<Integer,MyEnum>> enumMapDFset) {
    this.enumMapDFset = enumMapDFset;
    return this;
  }

  public void unsetEnumMapDFset() {
    this.enumMapDFset = null;
  }

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

  public void setEnumMapDFsetIsSet(boolean __value) {
    if (!__value) {
      this.enumMapDFset = null;
    }
  }

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

    case MYLONGDF:
      if (__value == null) {
        unsetMyLongDF();
      } else {
        setMyLongDF((Long)__value);
      }
      break;

    case PORTDFSET:
      if (__value == null) {
        unsetPortDFset();
      } else {
        setPortDFset((Integer)__value);
      }
      break;

    case PORTNUM:
      if (__value == null) {
        unsetPortNum();
      } else {
        setPortNum((Integer)__value);
      }
      break;

    case MYBINARYDFSET:
      if (__value == null) {
        unsetMyBinaryDFset();
      } else {
        setMyBinaryDFset((byte[])__value);
      }
      break;

    case MYBINARY:
      if (__value == null) {
        unsetMyBinary();
      } else {
        setMyBinary((byte[])__value);
      }
      break;

    case MYBYTEDFSET:
      if (__value == null) {
        unsetMyByteDFSet();
      } else {
        setMyByteDFSet((Byte)__value);
      }
      break;

    case MYBYTE:
      if (__value == null) {
        unsetMyByte();
      } else {
        setMyByte((Byte)__value);
      }
      break;

    case MYDOUBLEDFSET:
      if (__value == null) {
        unsetMyDoubleDFset();
      } else {
        setMyDoubleDFset((Double)__value);
      }
      break;

    case MYDOUBLEDFZERO:
      if (__value == null) {
        unsetMyDoubleDFZero();
      } else {
        setMyDoubleDFZero((Double)__value);
      }
      break;

    case MYDOUBLE:
      if (__value == null) {
        unsetMyDouble();
      } else {
        setMyDouble((Double)__value);
      }
      break;

    case FIELD3:
      if (__value == null) {
        unsetField3();
      } else {
        setField3((Map<Integer,String>)__value);
      }
      break;

    case MYLIST:
      if (__value == null) {
        unsetMyList();
      } else {
        setMyList((List<MyEnum>)__value);
      }
      break;

    case MYSET:
      if (__value == null) {
        unsetMySet();
      } else {
        setMySet((Set<String>)__value);
      }
      break;

    case SIMPLESTRUCT:
      if (__value == null) {
        unsetSimpleStruct();
      } else {
        setSimpleStruct((SimpleStruct)__value);
      }
      break;

    case LISTSTRUCTDFSET:
      if (__value == null) {
        unsetListStructDFset();
      } else {
        setListStructDFset((List<SimpleStruct>)__value);
      }
      break;

    case MYUNION:
      if (__value == null) {
        unsetMyUnion();
      } else {
        setMyUnion((MyUnion)__value);
      }
      break;

    case LISTUNIONDFSET:
      if (__value == null) {
        unsetListUnionDFset();
      } else {
        setListUnionDFset((List<MyUnion>)__value);
      }
      break;

    case MAPNESTLISTSTRUCTDFSET:
      if (__value == null) {
        unsetMapNestlistStructDfSet();
      } else {
        setMapNestlistStructDfSet((Map<Integer,List<SimpleStruct>>)__value);
      }
      break;

    case MAPJAVATYPEDFSET:
      if (__value == null) {
        unsetMapJavaTypeDFset();
      } else {
        setMapJavaTypeDFset((Map<Long,String>)__value);
      }
      break;

    case EMPTYMAP:
      if (__value == null) {
        unsetEmptyMap();
      } else {
        setEmptyMap((Map<Long,Integer>)__value);
      }
      break;

    case ENUMMAPDFSET:
      if (__value == null) {
        unsetEnumMapDFset();
      } else {
        setEnumMapDFset((Map<String,Map<Integer,MyEnum>>)__value);
      }
      break;

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

  public Object getFieldValue(int fieldID) {
    switch (fieldID) {
    case MYLONGDFSET:
      return new Long(getMyLongDFset());

    case MYLONGDF:
      return new Long(getMyLongDF());

    case PORTDFSET:
      return new Integer(getPortDFset());

    case PORTNUM:
      return new Integer(getPortNum());

    case MYBINARYDFSET:
      return getMyBinaryDFset();

    case MYBINARY:
      return getMyBinary();

    case MYBYTEDFSET:
      return new Byte(getMyByteDFSet());

    case MYBYTE:
      return new Byte(getMyByte());

    case MYDOUBLEDFSET:
      return new Double(getMyDoubleDFset());

    case MYDOUBLEDFZERO:
      return new Double(getMyDoubleDFZero());

    case MYDOUBLE:
      return new Double(getMyDouble());

    case FIELD3:
      return getField3();

    case MYLIST:
      return getMyList();

    case MYSET:
      return getMySet();

    case SIMPLESTRUCT:
      return getSimpleStruct();

    case LISTSTRUCTDFSET:
      return getListStructDFset();

    case MYUNION:
      return getMyUnion();

    case LISTUNIONDFSET:
      return getListUnionDFset();

    case MAPNESTLISTSTRUCTDFSET:
      return getMapNestlistStructDfSet();

    case MAPJAVATYPEDFSET:
      return getMapJavaTypeDFset();

    case EMPTYMAP:
      return getEmptyMap();

    case ENUMMAPDFSET:
      return getEnumMapDFset();

    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 defaultStruct))
      return false;
    defaultStruct that = (defaultStruct)_that;

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

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

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

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

    if (!TBaseHelper.equalsSlow(this.isSetMyBinaryDFset(), that.isSetMyBinaryDFset(), this.myBinaryDFset, that.myBinaryDFset)) { return false; }

    if (!TBaseHelper.equalsSlow(this.isSetMyBinary(), that.isSetMyBinary(), this.myBinary, that.myBinary)) { return false; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return true;
  }

  @Override
  public int hashCode() {
    return Arrays.deepHashCode(new Object[] {myLongDFset, myLongDF, portDFset, portNum, myBinaryDFset, myBinary, myByteDFSet, myByte, myDoubleDFset, myDoubleDFZero, myDouble, field3, myList, mySet, simpleStruct, listStructDFset, myUnion, listUnionDFset, mapNestlistStructDfSet, mapJavaTypeDFset, emptyMap, enumMapDFset});
  }

  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 MYLONGDFSET:
          if (__field.type == TType.I64) {
            this.myLongDFset = iprot.readI64();
            setMyLongDFsetIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYLONGDF:
          if (__field.type == TType.I64) {
            this.myLongDF = iprot.readI64();
            setMyLongDFIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case PORTDFSET:
          if (__field.type == TType.I32) {
            this.portDFset = iprot.readI32();
            setPortDFsetIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case PORTNUM:
          if (__field.type == TType.I32) {
            this.portNum = iprot.readI32();
            setPortNumIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBINARYDFSET:
          if (__field.type == TType.STRING) {
            this.myBinaryDFset = iprot.readBinary();
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBINARY:
          if (__field.type == TType.STRING) {
            this.myBinary = iprot.readBinary();
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBYTEDFSET:
          if (__field.type == TType.BYTE) {
            this.myByteDFSet = iprot.readByte();
            setMyByteDFSetIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYBYTE:
          if (__field.type == TType.BYTE) {
            this.myByte = iprot.readByte();
            setMyByteIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYDOUBLEDFSET:
          if (__field.type == TType.DOUBLE) {
            this.myDoubleDFset = iprot.readDouble();
            setMyDoubleDFsetIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYDOUBLEDFZERO:
          if (__field.type == TType.DOUBLE) {
            this.myDoubleDFZero = iprot.readDouble();
            setMyDoubleDFZeroIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYDOUBLE:
          if (__field.type == TType.DOUBLE) {
            this.myDouble = iprot.readDouble();
            setMyDoubleIsSet(true);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case FIELD3:
          if (__field.type == TType.MAP) {
            {
              TMap _map120 = iprot.readMapBegin();
              this.field3 = new HashMap<Integer,String>(Math.max(0, 2*_map120.size));
              for (int _i121 = 0; 
                   (_map120.size < 0) ? iprot.peekMap() : (_i121 < _map120.size); 
                   ++_i121)
              {
                int _key122;
                String _val123;
                _key122 = iprot.readI32();
                _val123 = iprot.readString();
                this.field3.put(_key122, _val123);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYLIST:
          if (__field.type == TType.LIST) {
            {
              TList _list124 = iprot.readListBegin();
              this.myList = new ArrayList<MyEnum>(Math.max(0, _list124.size));
              for (int _i125 = 0; 
                   (_list124.size < 0) ? iprot.peekList() : (_i125 < _list124.size); 
                   ++_i125)
              {
                MyEnum _elem126;
                _elem126 = MyEnum.findByValue(iprot.readI32());
                this.myList.add(_elem126);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYSET:
          if (__field.type == TType.SET) {
            {
              TSet _set127 = iprot.readSetBegin();
              this.mySet = new HashSet<String>(Math.max(0, 2*_set127.size));
              for (int _i128 = 0; 
                   (_set127.size < 0) ? iprot.peekSet() : (_i128 < _set127.size); 
                   ++_i128)
              {
                String _elem129;
                _elem129 = iprot.readString();
                this.mySet.add(_elem129);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SIMPLESTRUCT:
          if (__field.type == TType.STRUCT) {
            this.simpleStruct = new SimpleStruct();
            this.simpleStruct.read(iprot);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTSTRUCTDFSET:
          if (__field.type == TType.LIST) {
            {
              TList _list130 = iprot.readListBegin();
              this.listStructDFset = new ArrayList<SimpleStruct>(Math.max(0, _list130.size));
              for (int _i131 = 0; 
                   (_list130.size < 0) ? iprot.peekList() : (_i131 < _list130.size); 
                   ++_i131)
              {
                SimpleStruct _elem132;
                _elem132 = new SimpleStruct();
                _elem132.read(iprot);
                this.listStructDFset.add(_elem132);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MYUNION:
          if (__field.type == TType.STRUCT) {
            this.myUnion = new MyUnion();
            this.myUnion.read(iprot);
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTUNIONDFSET:
          if (__field.type == TType.LIST) {
            {
              TList _list133 = iprot.readListBegin();
              this.listUnionDFset = new ArrayList<MyUnion>(Math.max(0, _list133.size));
              for (int _i134 = 0; 
                   (_list133.size < 0) ? iprot.peekList() : (_i134 < _list133.size); 
                   ++_i134)
              {
                MyUnion _elem135;
                _elem135 = new MyUnion();
                _elem135.read(iprot);
                this.listUnionDFset.add(_elem135);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPNESTLISTSTRUCTDFSET:
          if (__field.type == TType.MAP) {
            {
              TMap _map136 = iprot.readMapBegin();
              this.mapNestlistStructDfSet = new HashMap<Integer,List<SimpleStruct>>(Math.max(0, 2*_map136.size));
              for (int _i137 = 0; 
                   (_map136.size < 0) ? iprot.peekMap() : (_i137 < _map136.size); 
                   ++_i137)
              {
                int _key138;
                List<SimpleStruct> _val139;
                _key138 = iprot.readI32();
                {
                  TList _list140 = iprot.readListBegin();
                  _val139 = new ArrayList<SimpleStruct>(Math.max(0, _list140.size));
                  for (int _i141 = 0; 
                       (_list140.size < 0) ? iprot.peekList() : (_i141 < _list140.size); 
                       ++_i141)
                  {
                    SimpleStruct _elem142;
                    _elem142 = new SimpleStruct();
                    _elem142.read(iprot);
                    _val139.add(_elem142);
                  }
                  iprot.readListEnd();
                }
                this.mapNestlistStructDfSet.put(_key138, _val139);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPJAVATYPEDFSET:
          if (__field.type == TType.MAP) {
            {
              TMap _map143 = iprot.readMapBegin();
              this.mapJavaTypeDFset = new HashMap<Long,String>(Math.max(0, 2*_map143.size));
              for (int _i144 = 0; 
                   (_map143.size < 0) ? iprot.peekMap() : (_i144 < _map143.size); 
                   ++_i144)
              {
                long _key145;
                String _val146;
                _key145 = iprot.readI64();
                _val146 = iprot.readString();
                this.mapJavaTypeDFset.put(_key145, _val146);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case EMPTYMAP:
          if (__field.type == TType.MAP) {
            {
              TMap _map147 = iprot.readMapBegin();
              this.emptyMap = new HashMap<Long,Integer>(Math.max(0, 2*_map147.size));
              for (int _i148 = 0; 
                   (_map147.size < 0) ? iprot.peekMap() : (_i148 < _map147.size); 
                   ++_i148)
              {
                long _key149;
                int _val150;
                _key149 = iprot.readI64();
                _val150 = iprot.readI32();
                this.emptyMap.put(_key149, _val150);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case ENUMMAPDFSET:
          if (__field.type == TType.MAP) {
            {
              TMap _map151 = iprot.readMapBegin();
              this.enumMapDFset = new HashMap<String,Map<Integer,MyEnum>>(Math.max(0, 2*_map151.size));
              for (int _i152 = 0; 
                   (_map151.size < 0) ? iprot.peekMap() : (_i152 < _map151.size); 
                   ++_i152)
              {
                String _key153;
                Map<Integer,MyEnum> _val154;
                _key153 = iprot.readString();
                {
                  TMap _map155 = iprot.readMapBegin();
                  _val154 = new HashMap<Integer,MyEnum>(Math.max(0, 2*_map155.size));
                  for (int _i156 = 0; 
                       (_map155.size < 0) ? iprot.peekMap() : (_i156 < _map155.size); 
                       ++_i156)
                  {
                    int _key157;
                    MyEnum _val158;
                    _key157 = iprot.readI32();
                    _val158 = MyEnum.findByValue(iprot.readI32());
                    _val154.put(_key157, _val158);
                  }
                  iprot.readMapEnd();
                }
                this.enumMapDFset.put(_key153, _val154);
              }
              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_LONG_DFSET_FIELD_DESC);
    oprot.writeI64(this.myLongDFset);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_LONG_DF_FIELD_DESC);
    oprot.writeI64(this.myLongDF);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(PORT_DFSET_FIELD_DESC);
    oprot.writeI32(this.portDFset);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(PORT_NUM_FIELD_DESC);
    oprot.writeI32(this.portNum);
    oprot.writeFieldEnd();
    if (this.myBinaryDFset != null) {
      oprot.writeFieldBegin(MY_BINARY_DFSET_FIELD_DESC);
      oprot.writeBinary(this.myBinaryDFset);
      oprot.writeFieldEnd();
    }
    if (this.myBinary != null) {
      oprot.writeFieldBegin(MY_BINARY_FIELD_DESC);
      oprot.writeBinary(this.myBinary);
      oprot.writeFieldEnd();
    }
    oprot.writeFieldBegin(MY_BYTE_DFSET_FIELD_DESC);
    oprot.writeByte(this.myByteDFSet);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_BYTE_FIELD_DESC);
    oprot.writeByte(this.myByte);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_DOUBLE_DFSET_FIELD_DESC);
    oprot.writeDouble(this.myDoubleDFset);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_DOUBLE_DFZERO_FIELD_DESC);
    oprot.writeDouble(this.myDoubleDFZero);
    oprot.writeFieldEnd();
    oprot.writeFieldBegin(MY_DOUBLE_FIELD_DESC);
    oprot.writeDouble(this.myDouble);
    oprot.writeFieldEnd();
    if (this.field3 != null) {
      oprot.writeFieldBegin(FIELD3_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, this.field3.size()));
        for (Map.Entry<Integer, String> _iter159 : this.field3.entrySet())        {
          oprot.writeI32(_iter159.getKey());
          oprot.writeString(_iter159.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.myList != null) {
      oprot.writeFieldBegin(MY_LIST_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.I32, this.myList.size()));
        for (MyEnum _iter160 : this.myList)        {
          oprot.writeI32(_iter160 == null ? 0 : _iter160.getValue());
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mySet != null) {
      oprot.writeFieldBegin(MY_SET_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.STRING, this.mySet.size()));
        for (String _iter161 : this.mySet)        {
          oprot.writeString(_iter161);
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.simpleStruct != null) {
      oprot.writeFieldBegin(SIMPLE_STRUCT_FIELD_DESC);
      this.simpleStruct.write(oprot);
      oprot.writeFieldEnd();
    }
    if (this.listStructDFset != null) {
      oprot.writeFieldBegin(LIST_STRUCT_DFSET_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.STRUCT, this.listStructDFset.size()));
        for (SimpleStruct _iter162 : this.listStructDFset)        {
          _iter162.write(oprot);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.myUnion != null) {
      oprot.writeFieldBegin(MY_UNION_FIELD_DESC);
      this.myUnion.write(oprot);
      oprot.writeFieldEnd();
    }
    if (this.listUnionDFset != null) {
      oprot.writeFieldBegin(LIST_UNION_DFSET_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.STRUCT, this.listUnionDFset.size()));
        for (MyUnion _iter163 : this.listUnionDFset)        {
          _iter163.write(oprot);
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapNestlistStructDfSet != null) {
      oprot.writeFieldBegin(MAP_NESTLIST_STRUCT_DF_SET_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.LIST, this.mapNestlistStructDfSet.size()));
        for (Map.Entry<Integer, List<SimpleStruct>> _iter164 : this.mapNestlistStructDfSet.entrySet())        {
          oprot.writeI32(_iter164.getKey());
          {
            oprot.writeListBegin(new TList(TType.STRUCT, _iter164.getValue().size()));
            for (SimpleStruct _iter165 : _iter164.getValue())            {
              _iter165.write(oprot);
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapJavaTypeDFset != null) {
      oprot.writeFieldBegin(MAP_JAVA_TYPE_DFSET_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I64, TType.STRING, this.mapJavaTypeDFset.size()));
        for (Map.Entry<Long, String> _iter166 : this.mapJavaTypeDFset.entrySet())        {
          oprot.writeI64(_iter166.getKey());
          oprot.writeString(_iter166.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.emptyMap != null) {
      oprot.writeFieldBegin(EMPTY_MAP_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I64, TType.I32, this.emptyMap.size()));
        for (Map.Entry<Long, Integer> _iter167 : this.emptyMap.entrySet())        {
          oprot.writeI64(_iter167.getKey());
          oprot.writeI32(_iter167.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.enumMapDFset != null) {
      oprot.writeFieldBegin(ENUM_MAP_DFSET_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.STRING, TType.MAP, this.enumMapDFset.size()));
        for (Map.Entry<String, Map<Integer,MyEnum>> _iter168 : this.enumMapDFset.entrySet())        {
          oprot.writeString(_iter168.getKey());
          {
            oprot.writeMapBegin(new TMap(TType.I32, TType.I32, _iter168.getValue().size()));
            for (Map.Entry<Integer, MyEnum> _iter169 : _iter168.getValue().entrySet())            {
              oprot.writeI32(_iter169.getKey());
              oprot.writeI32(_iter169.getValue() == null ? 0 : _iter169.getValue().getValue());
            }
            oprot.writeMapEnd();
          }
        }
        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("defaultStruct");
    sb.append(space);
    sb.append("(");
    sb.append(newLine);
    boolean first = true;

    sb.append(indentStr);
    sb.append("myLongDFset");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyLongDFset(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myLongDF");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyLongDF(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("portDFset");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getPortDFset(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("portNum");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getPortNum(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myBinaryDFset");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyBinaryDFset() == null) {
      sb.append("null");
    } else {
        int __myBinaryDFset_size = Math.min(this.getMyBinaryDFset().length, 128);
        for (int i = 0; i < __myBinaryDFset_size; i++) {
          if (i != 0) sb.append(" ");
          sb.append(Integer.toHexString(this.getMyBinaryDFset()[i]).length() > 1 ? Integer.toHexString(this.getMyBinaryDFset()[i]).substring(Integer.toHexString(this.getMyBinaryDFset()[i]).length() - 2).toUpperCase() : "0" + Integer.toHexString(this.getMyBinaryDFset()[i]).toUpperCase());
        }
        if (this.getMyBinaryDFset().length > 128) sb.append(" ...");
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myBinary");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyBinary() == null) {
      sb.append("null");
    } else {
        int __myBinary_size = Math.min(this.getMyBinary().length, 128);
        for (int i = 0; i < __myBinary_size; i++) {
          if (i != 0) sb.append(" ");
          sb.append(Integer.toHexString(this.getMyBinary()[i]).length() > 1 ? Integer.toHexString(this.getMyBinary()[i]).substring(Integer.toHexString(this.getMyBinary()[i]).length() - 2).toUpperCase() : "0" + Integer.toHexString(this.getMyBinary()[i]).toUpperCase());
        }
        if (this.getMyBinary().length > 128) sb.append(" ...");
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myByteDFSet");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyByteDFSet(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myByte");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyByte(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myDoubleDFset");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyDoubleDFset(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myDoubleDFZero");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyDoubleDFZero(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myDouble");
    sb.append(space);
    sb.append(":").append(space);
    sb.append(TBaseHelper.toString(this.getMyDouble(), indent + 1, prettyPrint));
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("field3");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getField3() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getField3(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myList");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyList() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMyList(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mySet");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMySet() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMySet(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("simpleStruct");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSimpleStruct() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSimpleStruct(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listStructDFset");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListStructDFset() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListStructDFset(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("myUnion");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMyUnion() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMyUnion(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listUnionDFset");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListUnionDFset() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListUnionDFset(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapNestlistStructDfSet");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapNestlistStructDfSet() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapNestlistStructDfSet(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapJavaTypeDFset");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapJavaTypeDFset() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapJavaTypeDFset(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("emptyMap");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getEmptyMap() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getEmptyMap(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("enumMapDFset");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getEnumMapDFset() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getEnumMapDFset(), 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
  }

}

