summaryrefslogblamecommitdiffstats
path: root/src/main/java/org/openslx/bwlp/thrift/iface/LectureRead.java
blob: 9ba4c287542ee05ec24f3867dcb4b32bc348a4c8 (plain) (tree)
1
2
   
                                           




























                                                                   
                                  


                               
                                                              
                                                                                   





                                                                                                                                                                                           

                                                                                                                                                                                                   





                                                                                                                                                                                       

                                                                                                                                                                                       








                                                                                                                                                                                                          
                                                                                                                                                                                                    
                                                                                                                                                                                          

                                                                                                                                                                                                            
                                                                                                                                                                                             
                                                                                                                                                                                              









                                                                                                                                     

                                           
                                        




                                       

                                     

                                      



                                                     



                                                           
                                               

                                                 
                                          
                                                  





                                                                                                                  

                                                  





                                        

                                         








                                                         
                                                   

                                                      
                                                             

                                               



















                                                                                      



                                    


                              
                            
                             
                            
                           
                          
                            
                           
                             
                           



                               
                            
                          
                              
                            








                                      
                         
                                       
                                     
                                       
                                     
                                    
                                  

                                



                                          

                                  

                                  







































                                                                                                     





                                                     



                                                            

                                                               
                                                        
                                     
                                                                                               








                                                                                                                                                    



                                                                                                                                                          

                                                                                                                                                 









                                                                                                                                               



                                                                                                                                                 



                                                                                                                                               










                                                                                                                                                               







                                                                                                                                                                 


                                                                                                                                                   



                                                                                                                                                                     

                                                                                                                                                      


                                                                                                                                                        










                                                                                                   

                          
                       




                      

                    

                     



                                    

                              
                                          

                              

                                




                                   

                                         

                                 









                               



                                 

                               



                                               




                                                 
                                   



                                                   

                                     















                                              




                                                 
     
                                       




                                     

                                       





                                       

















                                                                                                       







                                                                                 



                                                                                    

                                                         
                                           






                                                                                                 










                                 

                               

                              









                             



                              

                          



                                  





                                     
                            



                                       

                                
                              









































































                                                                                                 

























                                                                                                    

   

                                                         


                

                                  

   


                                                                                                 

   
                                                  
                 
                              


     






















                                                                                                


















































































































                                                                                               













































                                                                                                















































                                                                                               












































































































































                                                                                                       





























































































                                                                                                        






































                                                                                                 













































                                                                                                         






















                                                                                                  






































                                                                                                   

























                                                          
                          
                          
                              
              








                                         


            







                                      







































                                     















                                   















                                    































                                                   































                                                         







                                             















                                               







                                        







                                                













                                              




                                 
 
                     
                            
 
                    
                           

                    
                            

                  
                          

                   
                           

                   
                           
 
                     
                             

                     
                             
 





                            











                                    
                 
                        

                             
                                   






                                     


                              





                                     


                              


                                
















                                                                                                              



                                   

                               









                              



                               



                              







                                      







                                       

                                



                                        

                                 

                                  











































                                                                       












                                                                             
                     
                                                     


                     








                                                                












































                                                              

















                                                                

















                                                                   



































                                                                                   



































                                                                                     








                                                                       

















                                                                                  








                                                                    








                                                                           




                         

























































































































                                                                             









                                               




                                        




                                                                   
                           







































                                                                                                    
                                                                                                   


                              











                                                                                                          



                                









                                                                                                  

















































                                                                                                



















                                                                                                  



















                                                                                                







































                                                                                                                







































                                                                                                                  









                                                                                                    



















                                                                                                                    









                                                                                                      









                                                                                                        











































                                                                                                     









                                      

                        
                                  


                                



                                



















                                







                                















                                 































                                         
























                                          







                                   







                                        



                                 









                                       






                                                              



































































                                                                                                                                    











                                                                                     



                                                                                     








                                                                                     






                                                                                     
                               






                                                                                     
                             






                                                                                     
                              






                                                                                     
                               






                                                                                     















                                                                                     
                              






                                                                                     
                                






                                                                                     










                                                                                     



                                                                                  
                 

                                                










                                                                                     



                                                                                  
                 

                                                    










                                                                                     



                                                                                  
                 


                                                         








                                                                                     






                                                                                     
                                         






                                                                                     
                                         







                                                                                     
                                      







                                                                                     


                                                                            



                                                                                  
                 

                                                   







                                                                                     















                                                                                     







                                                                                     


















                                                                                     





























                                                                                                                           


                                                    
























                                                     








                                                                                                                                  
                                             
           
                                        








                                                                                                                                          
                                                     
           
                                        








                                                                                                                                               
                                                           
           
                                  




                               










                                                              





                                                    






                                                             









                                                           



                                                                                                                                      
                                                 
           
                                     




                               





                                                               


                                                       













                                                                                                                                             


























                                                                                                                          
                                         

                         
                                      

                         
                                     

                         
                                    

                         
                                    

                         
                                  

                         
                                   

                         
                                   

                          
                                     

                          
                                     

                          
                                  

                          
                                    

                          
                                    

                          
                               

                          
                                       

                          
                                            

                          
                                 

                          
                                            

                          
                                             

                          


                                          


                                      





                                              


                                       



                                        








                                              




                                                 
       


                                           














                                          





                                          





                                            





                                             
                                             
           
                                        





                                                     
                                                     
           
                                        





                                                          
                                                           
           
                                  


           











                                                  


                                                    
                                                 
           
                                     


           





                                                    


                                             








                                                        




                                                                                                                         
                                             












                                                

                                                   

                            



                                                


                                             
                            


                                            
                            


                                           
                            


                                         
                            


                                          
                             


                                          
                             


                                            
                             


                                            
                             


                                            
                             


                                              
                             


                                              
                             
         



                                                                                                                                                     
           

                                          



                                  
                             
         



                                                                                                                                                     
           

                                              



                                          
                             
         



                                                                                                                                                     
           


                                                   



                                               
                             


                                         
                             


                                                    
                             



                                                             
                             



                                                          

                             



                                                                                                                                                  
           

                                             



                                         







                                                      



                                               













                                                                                                                                                     




     
/**
 * Autogenerated by Thrift Compiler (0.9.3)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
package org.openslx.bwlp.thrift.iface;

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

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

@SuppressWarnings({"cast", "rawtypes", "serial", "unchecked"})
@Generated(value = "Autogenerated by Thrift Compiler (0.9.3)", date = "2017-09-06")
public class LectureRead implements org.apache.thrift.TBase<LectureRead, LectureRead._Fields>, java.io.Serializable, Cloneable, Comparable<LectureRead> {
  private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("LectureRead");

  private static final org.apache.thrift.protocol.TField LECTURE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureId", org.apache.thrift.protocol.TType.STRING, (short)1);
  private static final org.apache.thrift.protocol.TField LECTURE_NAME_FIELD_DESC = new org.apache.thrift.protocol.TField("lectureName", org.apache.thrift.protocol.TType.STRING, (short)2);
  private static final org.apache.thrift.protocol.TField DESCRIPTION_FIELD_DESC = new org.apache.thrift.protocol.TField("description", org.apache.thrift.protocol.TType.STRING, (short)3);
  private static final org.apache.thrift.protocol.TField IMAGE_VERSION_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageVersionId", org.apache.thrift.protocol.TType.STRING, (short)23);
  private static final org.apache.thrift.protocol.TField IMAGE_BASE_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("imageBaseId", org.apache.thrift.protocol.TType.STRING, (short)24);
  private static final org.apache.thrift.protocol.TField AUTO_UPDATE_FIELD_DESC = new org.apache.thrift.protocol.TField("autoUpdate", org.apache.thrift.protocol.TType.BOOL, (short)5);
  private static final org.apache.thrift.protocol.TField IS_ENABLED_FIELD_DESC = new org.apache.thrift.protocol.TField("isEnabled", org.apache.thrift.protocol.TType.BOOL, (short)6);
  private static final org.apache.thrift.protocol.TField START_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("startTime", org.apache.thrift.protocol.TType.I64, (short)7);
  private static final org.apache.thrift.protocol.TField END_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("endTime", org.apache.thrift.protocol.TType.I64, (short)8);
  private static final org.apache.thrift.protocol.TField LAST_USED_FIELD_DESC = new org.apache.thrift.protocol.TField("lastUsed", org.apache.thrift.protocol.TType.I64, (short)9);
  private static final org.apache.thrift.protocol.TField USE_COUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("useCount", org.apache.thrift.protocol.TType.I32, (short)10);
  private static final org.apache.thrift.protocol.TField CREATE_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("createTime", org.apache.thrift.protocol.TType.I64, (short)20);
  private static final org.apache.thrift.protocol.TField UPDATE_TIME_FIELD_DESC = new org.apache.thrift.protocol.TField("updateTime", org.apache.thrift.protocol.TType.I64, (short)21);
  private static final org.apache.thrift.protocol.TField OWNER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("ownerId", org.apache.thrift.protocol.TType.STRING, (short)11);
  private static final org.apache.thrift.protocol.TField UPDATER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("updaterId", org.apache.thrift.protocol.TType.STRING, (short)12);
  private static final org.apache.thrift.protocol.TField RUNSCRIPT_FIELD_DESC = new org.apache.thrift.protocol.TField("runscript", org.apache.thrift.protocol.TType.STRING, (short)13);
  private static final org.apache.thrift.protocol.TField NICS_FIELD_DESC = new org.apache.thrift.protocol.TField("nics", org.apache.thrift.protocol.TType.LIST, (short)14);
  private static final org.apache.thrift.protocol.TField ALLOWED_USERS_FIELD_DESC = new org.apache.thrift.protocol.TField("allowedUsers", org.apache.thrift.protocol.TType.LIST, (short)15);
  private static final org.apache.thrift.protocol.TField NETWORK_EXCEPTIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("networkExceptions", org.apache.thrift.protocol.TType.LIST, (short)16);
  private static final org.apache.thrift.protocol.TField IS_EXAM_FIELD_DESC = new org.apache.thrift.protocol.TField("isExam", org.apache.thrift.protocol.TType.BOOL, (short)17);
  private static final org.apache.thrift.protocol.TField HAS_INTERNET_ACCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("hasInternetAccess", org.apache.thrift.protocol.TType.BOOL, (short)18);
  private static final org.apache.thrift.protocol.TField DEFAULT_PERMISSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("defaultPermissions", org.apache.thrift.protocol.TType.STRUCT, (short)19);
  private static final org.apache.thrift.protocol.TField USER_PERMISSIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("userPermissions", org.apache.thrift.protocol.TType.STRUCT, (short)22);
  private static final org.apache.thrift.protocol.TField LOCATION_IDS_FIELD_DESC = new org.apache.thrift.protocol.TField("locationIds", org.apache.thrift.protocol.TType.LIST, (short)25);
  private static final org.apache.thrift.protocol.TField LIMIT_TO_LOCATIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("limitToLocations", org.apache.thrift.protocol.TType.BOOL, (short)26);
  private static final org.apache.thrift.protocol.TField LIMIT_TO_ALLOWED_USERS_FIELD_DESC = new org.apache.thrift.protocol.TField("limitToAllowedUsers", org.apache.thrift.protocol.TType.BOOL, (short)27);
  private static final org.apache.thrift.protocol.TField HAS_USB_ACCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("hasUsbAccess", org.apache.thrift.protocol.TType.BOOL, (short)28);
  private static final org.apache.thrift.protocol.TField NETWORK_SHARES_FIELD_DESC = new org.apache.thrift.protocol.TField("networkShares", org.apache.thrift.protocol.TType.LIST, (short)29);

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

  public String lectureId; // required
  public String lectureName; // required
  public String description; // required
  public String imageVersionId; // required
  public String imageBaseId; // required
  public boolean autoUpdate; // required
  public boolean isEnabled; // required
  public long startTime; // required
  public long endTime; // required
  public long lastUsed; // required
  public int useCount; // required
  public long createTime; // required
  public long updateTime; // required
  public String ownerId; // required
  public String updaterId; // required
  public String runscript; // required
  public List<String> nics; // required
  public List<String> allowedUsers; // required
  public List<NetRule> networkExceptions; // required
  public boolean isExam; // required
  public boolean hasInternetAccess; // required
  public LecturePermissions defaultPermissions; // required
  public LecturePermissions userPermissions; // optional
  public List<Integer> locationIds; // required
  public boolean limitToLocations; // required
  public boolean limitToAllowedUsers; // required
  public boolean hasUsbAccess; // required
  public List<NetShare> networkShares; // optional

  /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
  public enum _Fields implements org.apache.thrift.TFieldIdEnum {
    LECTURE_ID((short)1, "lectureId"),
    LECTURE_NAME((short)2, "lectureName"),
    DESCRIPTION((short)3, "description"),
    IMAGE_VERSION_ID((short)23, "imageVersionId"),
    IMAGE_BASE_ID((short)24, "imageBaseId"),
    AUTO_UPDATE((short)5, "autoUpdate"),
    IS_ENABLED((short)6, "isEnabled"),
    START_TIME((short)7, "startTime"),
    END_TIME((short)8, "endTime"),
    LAST_USED((short)9, "lastUsed"),
    USE_COUNT((short)10, "useCount"),
    CREATE_TIME((short)20, "createTime"),
    UPDATE_TIME((short)21, "updateTime"),
    OWNER_ID((short)11, "ownerId"),
    UPDATER_ID((short)12, "updaterId"),
    RUNSCRIPT((short)13, "runscript"),
    NICS((short)14, "nics"),
    ALLOWED_USERS((short)15, "allowedUsers"),
    NETWORK_EXCEPTIONS((short)16, "networkExceptions"),
    IS_EXAM((short)17, "isExam"),
    HAS_INTERNET_ACCESS((short)18, "hasInternetAccess"),
    DEFAULT_PERMISSIONS((short)19, "defaultPermissions"),
    USER_PERMISSIONS((short)22, "userPermissions"),
    LOCATION_IDS((short)25, "locationIds"),
    LIMIT_TO_LOCATIONS((short)26, "limitToLocations"),
    LIMIT_TO_ALLOWED_USERS((short)27, "limitToAllowedUsers"),
    HAS_USB_ACCESS((short)28, "hasUsbAccess"),
    NETWORK_SHARES((short)29, "networkShares");

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

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

    /**
     * Find the _Fields constant that matches fieldId, or null if its not found.
     */
    public static _Fields findByThriftId(int fieldId) {
      switch(fieldId) {
        case 1: // LECTURE_ID
          return LECTURE_ID;
        case 2: // LECTURE_NAME
          return LECTURE_NAME;
        case 3: // DESCRIPTION
          return DESCRIPTION;
        case 23: // IMAGE_VERSION_ID
          return IMAGE_VERSION_ID;
        case 24: // IMAGE_BASE_ID
          return IMAGE_BASE_ID;
        case 5: // AUTO_UPDATE
          return AUTO_UPDATE;
        case 6: // IS_ENABLED
          return IS_ENABLED;
        case 7: // START_TIME
          return START_TIME;
        case 8: // END_TIME
          return END_TIME;
        case 9: // LAST_USED
          return LAST_USED;
        case 10: // USE_COUNT
          return USE_COUNT;
        case 20: // CREATE_TIME
          return CREATE_TIME;
        case 21: // UPDATE_TIME
          return UPDATE_TIME;
        case 11: // OWNER_ID
          return OWNER_ID;
        case 12: // UPDATER_ID
          return UPDATER_ID;
        case 13: // RUNSCRIPT
          return RUNSCRIPT;
        case 14: // NICS
          return NICS;
        case 15: // ALLOWED_USERS
          return ALLOWED_USERS;
        case 16: // NETWORK_EXCEPTIONS
          return NETWORK_EXCEPTIONS;
        case 17: // IS_EXAM
          return IS_EXAM;
        case 18: // HAS_INTERNET_ACCESS
          return HAS_INTERNET_ACCESS;
        case 19: // DEFAULT_PERMISSIONS
          return DEFAULT_PERMISSIONS;
        case 22: // USER_PERMISSIONS
          return USER_PERMISSIONS;
        case 25: // LOCATION_IDS
          return LOCATION_IDS;
        case 26: // LIMIT_TO_LOCATIONS
          return LIMIT_TO_LOCATIONS;
        case 27: // LIMIT_TO_ALLOWED_USERS
          return LIMIT_TO_ALLOWED_USERS;
        case 28: // HAS_USB_ACCESS
          return HAS_USB_ACCESS;
        case 29: // NETWORK_SHARES
          return NETWORK_SHARES;
        default:
          return null;
      }
    }

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

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

    private final short _thriftId;
    private final String _fieldName;

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

    public short getThriftFieldId() {
      return _thriftId;
    }

    public String getFieldName() {
      return _fieldName;
    }
  }

  // isset id assignments
  private static final int __AUTOUPDATE_ISSET_ID = 0;
  private static final int __ISENABLED_ISSET_ID = 1;
  private static final int __STARTTIME_ISSET_ID = 2;
  private static final int __ENDTIME_ISSET_ID = 3;
  private static final int __LASTUSED_ISSET_ID = 4;
  private static final int __USECOUNT_ISSET_ID = 5;
  private static final int __CREATETIME_ISSET_ID = 6;
  private static final int __UPDATETIME_ISSET_ID = 7;
  private static final int __ISEXAM_ISSET_ID = 8;
  private static final int __HASINTERNETACCESS_ISSET_ID = 9;
  private static final int __LIMITTOLOCATIONS_ISSET_ID = 10;
  private static final int __LIMITTOALLOWEDUSERS_ISSET_ID = 11;
  private static final int __HASUSBACCESS_ISSET_ID = 12;
  private short __isset_bitfield = 0;
  private static final _Fields optionals[] = {_Fields.USER_PERMISSIONS,_Fields.NETWORK_SHARES};
  public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
  static {
    Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
    tmpMap.put(_Fields.LECTURE_ID, new org.apache.thrift.meta_data.FieldMetaData("lectureId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "UUID")));
    tmpMap.put(_Fields.LECTURE_NAME, new org.apache.thrift.meta_data.FieldMetaData("lectureName", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.DESCRIPTION, new org.apache.thrift.meta_data.FieldMetaData("description", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.IMAGE_VERSION_ID, new org.apache.thrift.meta_data.FieldMetaData("imageVersionId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.IMAGE_BASE_ID, new org.apache.thrift.meta_data.FieldMetaData("imageBaseId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.AUTO_UPDATE, new org.apache.thrift.meta_data.FieldMetaData("autoUpdate", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.IS_ENABLED, new org.apache.thrift.meta_data.FieldMetaData("isEnabled", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.START_TIME, new org.apache.thrift.meta_data.FieldMetaData("startTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64        , "UnixTimestamp")));
    tmpMap.put(_Fields.END_TIME, new org.apache.thrift.meta_data.FieldMetaData("endTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64        , "UnixTimestamp")));
    tmpMap.put(_Fields.LAST_USED, new org.apache.thrift.meta_data.FieldMetaData("lastUsed", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64        , "UnixTimestamp")));
    tmpMap.put(_Fields.USE_COUNT, new org.apache.thrift.meta_data.FieldMetaData("useCount", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32)));
    tmpMap.put(_Fields.CREATE_TIME, new org.apache.thrift.meta_data.FieldMetaData("createTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64        , "UnixTimestamp")));
    tmpMap.put(_Fields.UPDATE_TIME, new org.apache.thrift.meta_data.FieldMetaData("updateTime", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64        , "UnixTimestamp")));
    tmpMap.put(_Fields.OWNER_ID, new org.apache.thrift.meta_data.FieldMetaData("ownerId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "UUID")));
    tmpMap.put(_Fields.UPDATER_ID, new org.apache.thrift.meta_data.FieldMetaData("updaterId", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING        , "UUID")));
    tmpMap.put(_Fields.RUNSCRIPT, new org.apache.thrift.meta_data.FieldMetaData("runscript", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING)));
    tmpMap.put(_Fields.NICS, new org.apache.thrift.meta_data.FieldMetaData("nics", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
    tmpMap.put(_Fields.ALLOWED_USERS, new org.apache.thrift.meta_data.FieldMetaData("allowedUsers", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
    tmpMap.put(_Fields.NETWORK_EXCEPTIONS, new org.apache.thrift.meta_data.FieldMetaData("networkExceptions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, NetRule.class))));
    tmpMap.put(_Fields.IS_EXAM, new org.apache.thrift.meta_data.FieldMetaData("isExam", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.HAS_INTERNET_ACCESS, new org.apache.thrift.meta_data.FieldMetaData("hasInternetAccess", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.DEFAULT_PERMISSIONS, new org.apache.thrift.meta_data.FieldMetaData("defaultPermissions", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LecturePermissions.class)));
    tmpMap.put(_Fields.USER_PERMISSIONS, new org.apache.thrift.meta_data.FieldMetaData("userPermissions", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, LecturePermissions.class)));
    tmpMap.put(_Fields.LOCATION_IDS, new org.apache.thrift.meta_data.FieldMetaData("locationIds", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I32))));
    tmpMap.put(_Fields.LIMIT_TO_LOCATIONS, new org.apache.thrift.meta_data.FieldMetaData("limitToLocations", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.LIMIT_TO_ALLOWED_USERS, new org.apache.thrift.meta_data.FieldMetaData("limitToAllowedUsers", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.HAS_USB_ACCESS, new org.apache.thrift.meta_data.FieldMetaData("hasUsbAccess", org.apache.thrift.TFieldRequirementType.DEFAULT, 
        new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
    tmpMap.put(_Fields.NETWORK_SHARES, new org.apache.thrift.meta_data.FieldMetaData("networkShares", org.apache.thrift.TFieldRequirementType.OPTIONAL, 
        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST, 
            new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, NetShare.class))));
    metaDataMap = Collections.unmodifiableMap(tmpMap);
    org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(LectureRead.class, metaDataMap);
  }

  public LectureRead() {
  }

  public LectureRead(
    String lectureId,
    String lectureName,
    String description,
    String imageVersionId,
    String imageBaseId,
    boolean autoUpdate,
    boolean isEnabled,
    long startTime,
    long endTime,
    long lastUsed,
    int useCount,
    long createTime,
    long updateTime,
    String ownerId,
    String updaterId,
    String runscript,
    List<String> nics,
    List<String> allowedUsers,
    List<NetRule> networkExceptions,
    boolean isExam,
    boolean hasInternetAccess,
    LecturePermissions defaultPermissions,
    List<Integer> locationIds,
    boolean limitToLocations,
    boolean limitToAllowedUsers,
    boolean hasUsbAccess)
  {
    this();
    this.lectureId = lectureId;
    this.lectureName = lectureName;
    this.description = description;
    this.imageVersionId = imageVersionId;
    this.imageBaseId = imageBaseId;
    this.autoUpdate = autoUpdate;
    setAutoUpdateIsSet(true);
    this.isEnabled = isEnabled;
    setIsEnabledIsSet(true);
    this.startTime = startTime;
    setStartTimeIsSet(true);
    this.endTime = endTime;
    setEndTimeIsSet(true);
    this.lastUsed = lastUsed;
    setLastUsedIsSet(true);
    this.useCount = useCount;
    setUseCountIsSet(true);
    this.createTime = createTime;
    setCreateTimeIsSet(true);
    this.updateTime = updateTime;
    setUpdateTimeIsSet(true);
    this.ownerId = ownerId;
    this.updaterId = updaterId;
    this.runscript = runscript;
    this.nics = nics;
    this.allowedUsers = allowedUsers;
    this.networkExceptions = networkExceptions;
    this.isExam = isExam;
    setIsExamIsSet(true);
    this.hasInternetAccess = hasInternetAccess;
    setHasInternetAccessIsSet(true);
    this.defaultPermissions = defaultPermissions;
    this.locationIds = locationIds;
    this.limitToLocations = limitToLocations;
    setLimitToLocationsIsSet(true);
    this.limitToAllowedUsers = limitToAllowedUsers;
    setLimitToAllowedUsersIsSet(true);
    this.hasUsbAccess = hasUsbAccess;
    setHasUsbAccessIsSet(true);
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public LectureRead(LectureRead other) {
    __isset_bitfield = other.__isset_bitfield;
    if (other.isSetLectureId()) {
      this.lectureId = other.lectureId;
    }
    if (other.isSetLectureName()) {
      this.lectureName = other.lectureName;
    }
    if (other.isSetDescription()) {
      this.description = other.description;
    }
    if (other.isSetImageVersionId()) {
      this.imageVersionId = other.imageVersionId;
    }
    if (other.isSetImageBaseId()) {
      this.imageBaseId = other.imageBaseId;
    }
    this.autoUpdate = other.autoUpdate;
    this.isEnabled = other.isEnabled;
    this.startTime = other.startTime;
    this.endTime = other.endTime;
    this.lastUsed = other.lastUsed;
    this.useCount = other.useCount;
    this.createTime = other.createTime;
    this.updateTime = other.updateTime;
    if (other.isSetOwnerId()) {
      this.ownerId = other.ownerId;
    }
    if (other.isSetUpdaterId()) {
      this.updaterId = other.updaterId;
    }
    if (other.isSetRunscript()) {
      this.runscript = other.runscript;
    }
    if (other.isSetNics()) {
      List<String> __this__nics = new ArrayList<String>(other.nics);
      this.nics = __this__nics;
    }
    if (other.isSetAllowedUsers()) {
      List<String> __this__allowedUsers = new ArrayList<String>(other.allowedUsers);
      this.allowedUsers = __this__allowedUsers;
    }
    if (other.isSetNetworkExceptions()) {
      List<NetRule> __this__networkExceptions = new ArrayList<NetRule>(other.networkExceptions.size());
      for (NetRule other_element : other.networkExceptions) {
        __this__networkExceptions.add(new NetRule(other_element));
      }
      this.networkExceptions = __this__networkExceptions;
    }
    this.isExam = other.isExam;
    this.hasInternetAccess = other.hasInternetAccess;
    if (other.isSetDefaultPermissions()) {
      this.defaultPermissions = new LecturePermissions(other.defaultPermissions);
    }
    if (other.isSetUserPermissions()) {
      this.userPermissions = new LecturePermissions(other.userPermissions);
    }
    if (other.isSetLocationIds()) {
      List<Integer> __this__locationIds = new ArrayList<Integer>(other.locationIds);
      this.locationIds = __this__locationIds;
    }
    this.limitToLocations = other.limitToLocations;
    this.limitToAllowedUsers = other.limitToAllowedUsers;
    this.hasUsbAccess = other.hasUsbAccess;
    if (other.isSetNetworkShares()) {
      List<NetShare> __this__networkShares = new ArrayList<NetShare>(other.networkShares.size());
      for (NetShare other_element : other.networkShares) {
        __this__networkShares.add(new NetShare(other_element));
      }
      this.networkShares = __this__networkShares;
    }
  }

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

  @Override
  public void clear() {
    this.lectureId = null;
    this.lectureName = null;
    this.description = null;
    this.imageVersionId = null;
    this.imageBaseId = null;
    setAutoUpdateIsSet(false);
    this.autoUpdate = false;
    setIsEnabledIsSet(false);
    this.isEnabled = false;
    setStartTimeIsSet(false);
    this.startTime = 0;
    setEndTimeIsSet(false);
    this.endTime = 0;
    setLastUsedIsSet(false);
    this.lastUsed = 0;
    setUseCountIsSet(false);
    this.useCount = 0;
    setCreateTimeIsSet(false);
    this.createTime = 0;
    setUpdateTimeIsSet(false);
    this.updateTime = 0;
    this.ownerId = null;
    this.updaterId = null;
    this.runscript = null;
    this.nics = null;
    this.allowedUsers = null;
    this.networkExceptions = null;
    setIsExamIsSet(false);
    this.isExam = false;
    setHasInternetAccessIsSet(false);
    this.hasInternetAccess = false;
    this.defaultPermissions = null;
    this.userPermissions = null;
    this.locationIds = null;
    setLimitToLocationsIsSet(false);
    this.limitToLocations = false;
    setLimitToAllowedUsersIsSet(false);
    this.limitToAllowedUsers = false;
    setHasUsbAccessIsSet(false);
    this.hasUsbAccess = false;
    this.networkShares = null;
  }

  public String getLectureId() {
    return this.lectureId;
  }

  public LectureRead setLectureId(String lectureId) {
    this.lectureId = lectureId;
    return this;
  }

  public void unsetLectureId() {
    this.lectureId = null;
  }

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

  public void setLectureIdIsSet(boolean value) {
    if (!value) {
      this.lectureId = null;
    }
  }

  public String getLectureName() {
    return this.lectureName;
  }

  public LectureRead setLectureName(String lectureName) {
    this.lectureName = lectureName;
    return this;
  }

  public void unsetLectureName() {
    this.lectureName = null;
  }

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

  public void setLectureNameIsSet(boolean value) {
    if (!value) {
      this.lectureName = null;
    }
  }

  public String getDescription() {
    return this.description;
  }

  public LectureRead setDescription(String description) {
    this.description = description;
    return this;
  }

  public void unsetDescription() {
    this.description = null;
  }

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

  public void setDescriptionIsSet(boolean value) {
    if (!value) {
      this.description = null;
    }
  }

  public String getImageVersionId() {
    return this.imageVersionId;
  }

  public LectureRead setImageVersionId(String imageVersionId) {
    this.imageVersionId = imageVersionId;
    return this;
  }

  public void unsetImageVersionId() {
    this.imageVersionId = null;
  }

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

  public void setImageVersionIdIsSet(boolean value) {
    if (!value) {
      this.imageVersionId = null;
    }
  }

  public String getImageBaseId() {
    return this.imageBaseId;
  }

  public LectureRead setImageBaseId(String imageBaseId) {
    this.imageBaseId = imageBaseId;
    return this;
  }

  public void unsetImageBaseId() {
    this.imageBaseId = null;
  }

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

  public void setImageBaseIdIsSet(boolean value) {
    if (!value) {
      this.imageBaseId = null;
    }
  }

  public boolean isAutoUpdate() {
    return this.autoUpdate;
  }

  public LectureRead setAutoUpdate(boolean autoUpdate) {
    this.autoUpdate = autoUpdate;
    setAutoUpdateIsSet(true);
    return this;
  }

  public void unsetAutoUpdate() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __AUTOUPDATE_ISSET_ID);
  }

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

  public void setAutoUpdateIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __AUTOUPDATE_ISSET_ID, value);
  }

  public boolean isIsEnabled() {
    return this.isEnabled;
  }

  public LectureRead setIsEnabled(boolean isEnabled) {
    this.isEnabled = isEnabled;
    setIsEnabledIsSet(true);
    return this;
  }

  public void unsetIsEnabled() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISENABLED_ISSET_ID);
  }

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

  public void setIsEnabledIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISENABLED_ISSET_ID, value);
  }

  public long getStartTime() {
    return this.startTime;
  }

  public LectureRead setStartTime(long startTime) {
    this.startTime = startTime;
    setStartTimeIsSet(true);
    return this;
  }

  public void unsetStartTime() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __STARTTIME_ISSET_ID);
  }

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

  public void setStartTimeIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __STARTTIME_ISSET_ID, value);
  }

  public long getEndTime() {
    return this.endTime;
  }

  public LectureRead setEndTime(long endTime) {
    this.endTime = endTime;
    setEndTimeIsSet(true);
    return this;
  }

  public void unsetEndTime() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ENDTIME_ISSET_ID);
  }

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

  public void setEndTimeIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ENDTIME_ISSET_ID, value);
  }

  public long getLastUsed() {
    return this.lastUsed;
  }

  public LectureRead setLastUsed(long lastUsed) {
    this.lastUsed = lastUsed;
    setLastUsedIsSet(true);
    return this;
  }

  public void unsetLastUsed() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LASTUSED_ISSET_ID);
  }

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

  public void setLastUsedIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LASTUSED_ISSET_ID, value);
  }

  public int getUseCount() {
    return this.useCount;
  }

  public LectureRead setUseCount(int useCount) {
    this.useCount = useCount;
    setUseCountIsSet(true);
    return this;
  }

  public void unsetUseCount() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __USECOUNT_ISSET_ID);
  }

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

  public void setUseCountIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __USECOUNT_ISSET_ID, value);
  }

  public long getCreateTime() {
    return this.createTime;
  }

  public LectureRead setCreateTime(long createTime) {
    this.createTime = createTime;
    setCreateTimeIsSet(true);
    return this;
  }

  public void unsetCreateTime() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __CREATETIME_ISSET_ID);
  }

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

  public void setCreateTimeIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __CREATETIME_ISSET_ID, value);
  }

  public long getUpdateTime() {
    return this.updateTime;
  }

  public LectureRead setUpdateTime(long updateTime) {
    this.updateTime = updateTime;
    setUpdateTimeIsSet(true);
    return this;
  }

  public void unsetUpdateTime() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __UPDATETIME_ISSET_ID);
  }

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

  public void setUpdateTimeIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __UPDATETIME_ISSET_ID, value);
  }

  public String getOwnerId() {
    return this.ownerId;
  }

  public LectureRead setOwnerId(String ownerId) {
    this.ownerId = ownerId;
    return this;
  }

  public void unsetOwnerId() {
    this.ownerId = null;
  }

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

  public void setOwnerIdIsSet(boolean value) {
    if (!value) {
      this.ownerId = null;
    }
  }

  public String getUpdaterId() {
    return this.updaterId;
  }

  public LectureRead setUpdaterId(String updaterId) {
    this.updaterId = updaterId;
    return this;
  }

  public void unsetUpdaterId() {
    this.updaterId = null;
  }

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

  public void setUpdaterIdIsSet(boolean value) {
    if (!value) {
      this.updaterId = null;
    }
  }

  public String getRunscript() {
    return this.runscript;
  }

  public LectureRead setRunscript(String runscript) {
    this.runscript = runscript;
    return this;
  }

  public void unsetRunscript() {
    this.runscript = null;
  }

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

  public void setRunscriptIsSet(boolean value) {
    if (!value) {
      this.runscript = null;
    }
  }

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

  public java.util.Iterator<String> getNicsIterator() {
    return (this.nics == null) ? null : this.nics.iterator();
  }

  public void addToNics(String elem) {
    if (this.nics == null) {
      this.nics = new ArrayList<String>();
    }
    this.nics.add(elem);
  }

  public List<String> getNics() {
    return this.nics;
  }

  public LectureRead setNics(List<String> nics) {
    this.nics = nics;
    return this;
  }

  public void unsetNics() {
    this.nics = null;
  }

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

  public void setNicsIsSet(boolean value) {
    if (!value) {
      this.nics = null;
    }
  }

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

  public java.util.Iterator<String> getAllowedUsersIterator() {
    return (this.allowedUsers == null) ? null : this.allowedUsers.iterator();
  }

  public void addToAllowedUsers(String elem) {
    if (this.allowedUsers == null) {
      this.allowedUsers = new ArrayList<String>();
    }
    this.allowedUsers.add(elem);
  }

  public List<String> getAllowedUsers() {
    return this.allowedUsers;
  }

  public LectureRead setAllowedUsers(List<String> allowedUsers) {
    this.allowedUsers = allowedUsers;
    return this;
  }

  public void unsetAllowedUsers() {
    this.allowedUsers = null;
  }

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

  public void setAllowedUsersIsSet(boolean value) {
    if (!value) {
      this.allowedUsers = null;
    }
  }

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

  public java.util.Iterator<NetRule> getNetworkExceptionsIterator() {
    return (this.networkExceptions == null) ? null : this.networkExceptions.iterator();
  }

  public void addToNetworkExceptions(NetRule elem) {
    if (this.networkExceptions == null) {
      this.networkExceptions = new ArrayList<NetRule>();
    }
    this.networkExceptions.add(elem);
  }

  public List<NetRule> getNetworkExceptions() {
    return this.networkExceptions;
  }

  public LectureRead setNetworkExceptions(List<NetRule> networkExceptions) {
    this.networkExceptions = networkExceptions;
    return this;
  }

  public void unsetNetworkExceptions() {
    this.networkExceptions = null;
  }

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

  public void setNetworkExceptionsIsSet(boolean value) {
    if (!value) {
      this.networkExceptions = null;
    }
  }

  public boolean isIsExam() {
    return this.isExam;
  }

  public LectureRead setIsExam(boolean isExam) {
    this.isExam = isExam;
    setIsExamIsSet(true);
    return this;
  }

  public void unsetIsExam() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __ISEXAM_ISSET_ID);
  }

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

  public void setIsExamIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __ISEXAM_ISSET_ID, value);
  }

  public boolean isHasInternetAccess() {
    return this.hasInternetAccess;
  }

  public LectureRead setHasInternetAccess(boolean hasInternetAccess) {
    this.hasInternetAccess = hasInternetAccess;
    setHasInternetAccessIsSet(true);
    return this;
  }

  public void unsetHasInternetAccess() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __HASINTERNETACCESS_ISSET_ID);
  }

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

  public void setHasInternetAccessIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __HASINTERNETACCESS_ISSET_ID, value);
  }

  public LecturePermissions getDefaultPermissions() {
    return this.defaultPermissions;
  }

  public LectureRead setDefaultPermissions(LecturePermissions defaultPermissions) {
    this.defaultPermissions = defaultPermissions;
    return this;
  }

  public void unsetDefaultPermissions() {
    this.defaultPermissions = null;
  }

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

  public void setDefaultPermissionsIsSet(boolean value) {
    if (!value) {
      this.defaultPermissions = null;
    }
  }

  public LecturePermissions getUserPermissions() {
    return this.userPermissions;
  }

  public LectureRead setUserPermissions(LecturePermissions userPermissions) {
    this.userPermissions = userPermissions;
    return this;
  }

  public void unsetUserPermissions() {
    this.userPermissions = null;
  }

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

  public void setUserPermissionsIsSet(boolean value) {
    if (!value) {
      this.userPermissions = null;
    }
  }

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

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

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

  public List<Integer> getLocationIds() {
    return this.locationIds;
  }

  public LectureRead setLocationIds(List<Integer> locationIds) {
    this.locationIds = locationIds;
    return this;
  }

  public void unsetLocationIds() {
    this.locationIds = null;
  }

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

  public void setLocationIdsIsSet(boolean value) {
    if (!value) {
      this.locationIds = null;
    }
  }

  public boolean isLimitToLocations() {
    return this.limitToLocations;
  }

  public LectureRead setLimitToLocations(boolean limitToLocations) {
    this.limitToLocations = limitToLocations;
    setLimitToLocationsIsSet(true);
    return this;
  }

  public void unsetLimitToLocations() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LIMITTOLOCATIONS_ISSET_ID);
  }

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

  public void setLimitToLocationsIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LIMITTOLOCATIONS_ISSET_ID, value);
  }

  public boolean isLimitToAllowedUsers() {
    return this.limitToAllowedUsers;
  }

  public LectureRead setLimitToAllowedUsers(boolean limitToAllowedUsers) {
    this.limitToAllowedUsers = limitToAllowedUsers;
    setLimitToAllowedUsersIsSet(true);
    return this;
  }

  public void unsetLimitToAllowedUsers() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __LIMITTOALLOWEDUSERS_ISSET_ID);
  }

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

  public void setLimitToAllowedUsersIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __LIMITTOALLOWEDUSERS_ISSET_ID, value);
  }

  public boolean isHasUsbAccess() {
    return this.hasUsbAccess;
  }

  public LectureRead setHasUsbAccess(boolean hasUsbAccess) {
    this.hasUsbAccess = hasUsbAccess;
    setHasUsbAccessIsSet(true);
    return this;
  }

  public void unsetHasUsbAccess() {
    __isset_bitfield = EncodingUtils.clearBit(__isset_bitfield, __HASUSBACCESS_ISSET_ID);
  }

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

  public void setHasUsbAccessIsSet(boolean value) {
    __isset_bitfield = EncodingUtils.setBit(__isset_bitfield, __HASUSBACCESS_ISSET_ID, value);
  }

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

  public java.util.Iterator<NetShare> getNetworkSharesIterator() {
    return (this.networkShares == null) ? null : this.networkShares.iterator();
  }

  public void addToNetworkShares(NetShare elem) {
    if (this.networkShares == null) {
      this.networkShares = new ArrayList<NetShare>();
    }
    this.networkShares.add(elem);
  }

  public List<NetShare> getNetworkShares() {
    return this.networkShares;
  }

  public LectureRead setNetworkShares(List<NetShare> networkShares) {
    this.networkShares = networkShares;
    return this;
  }

  public void unsetNetworkShares() {
    this.networkShares = null;
  }

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

  public void setNetworkSharesIsSet(boolean value) {
    if (!value) {
      this.networkShares = null;
    }
  }

  public void setFieldValue(_Fields field, Object value) {
    switch (field) {
    case LECTURE_ID:
      if (value == null) {
        unsetLectureId();
      } else {
        setLectureId((String)value);
      }
      break;

    case LECTURE_NAME:
      if (value == null) {
        unsetLectureName();
      } else {
        setLectureName((String)value);
      }
      break;

    case DESCRIPTION:
      if (value == null) {
        unsetDescription();
      } else {
        setDescription((String)value);
      }
      break;

    case IMAGE_VERSION_ID:
      if (value == null) {
        unsetImageVersionId();
      } else {
        setImageVersionId((String)value);
      }
      break;

    case IMAGE_BASE_ID:
      if (value == null) {
        unsetImageBaseId();
      } else {
        setImageBaseId((String)value);
      }
      break;

    case AUTO_UPDATE:
      if (value == null) {
        unsetAutoUpdate();
      } else {
        setAutoUpdate((Boolean)value);
      }
      break;

    case IS_ENABLED:
      if (value == null) {
        unsetIsEnabled();
      } else {
        setIsEnabled((Boolean)value);
      }
      break;

    case START_TIME:
      if (value == null) {
        unsetStartTime();
      } else {
        setStartTime((Long)value);
      }
      break;

    case END_TIME:
      if (value == null) {
        unsetEndTime();
      } else {
        setEndTime((Long)value);
      }
      break;

    case LAST_USED:
      if (value == null) {
        unsetLastUsed();
      } else {
        setLastUsed((Long)value);
      }
      break;

    case USE_COUNT:
      if (value == null) {
        unsetUseCount();
      } else {
        setUseCount((Integer)value);
      }
      break;

    case CREATE_TIME:
      if (value == null) {
        unsetCreateTime();
      } else {
        setCreateTime((Long)value);
      }
      break;

    case UPDATE_TIME:
      if (value == null) {
        unsetUpdateTime();
      } else {
        setUpdateTime((Long)value);
      }
      break;

    case OWNER_ID:
      if (value == null) {
        unsetOwnerId();
      } else {
        setOwnerId((String)value);
      }
      break;

    case UPDATER_ID:
      if (value == null) {
        unsetUpdaterId();
      } else {
        setUpdaterId((String)value);
      }
      break;

    case RUNSCRIPT:
      if (value == null) {
        unsetRunscript();
      } else {
        setRunscript((String)value);
      }
      break;

    case NICS:
      if (value == null) {
        unsetNics();
      } else {
        setNics((List<String>)value);
      }
      break;

    case ALLOWED_USERS:
      if (value == null) {
        unsetAllowedUsers();
      } else {
        setAllowedUsers((List<String>)value);
      }
      break;

    case NETWORK_EXCEPTIONS:
      if (value == null) {
        unsetNetworkExceptions();
      } else {
        setNetworkExceptions((List<NetRule>)value);
      }
      break;

    case IS_EXAM:
      if (value == null) {
        unsetIsExam();
      } else {
        setIsExam((Boolean)value);
      }
      break;

    case HAS_INTERNET_ACCESS:
      if (value == null) {
        unsetHasInternetAccess();
      } else {
        setHasInternetAccess((Boolean)value);
      }
      break;

    case DEFAULT_PERMISSIONS:
      if (value == null) {
        unsetDefaultPermissions();
      } else {
        setDefaultPermissions((LecturePermissions)value);
      }
      break;

    case USER_PERMISSIONS:
      if (value == null) {
        unsetUserPermissions();
      } else {
        setUserPermissions((LecturePermissions)value);
      }
      break;

    case LOCATION_IDS:
      if (value == null) {
        unsetLocationIds();
      } else {
        setLocationIds((List<Integer>)value);
      }
      break;

    case LIMIT_TO_LOCATIONS:
      if (value == null) {
        unsetLimitToLocations();
      } else {
        setLimitToLocations((Boolean)value);
      }
      break;

    case LIMIT_TO_ALLOWED_USERS:
      if (value == null) {
        unsetLimitToAllowedUsers();
      } else {
        setLimitToAllowedUsers((Boolean)value);
      }
      break;

    case HAS_USB_ACCESS:
      if (value == null) {
        unsetHasUsbAccess();
      } else {
        setHasUsbAccess((Boolean)value);
      }
      break;

    case NETWORK_SHARES:
      if (value == null) {
        unsetNetworkShares();
      } else {
        setNetworkShares((List<NetShare>)value);
      }
      break;

    }
  }

  public Object getFieldValue(_Fields field) {
    switch (field) {
    case LECTURE_ID:
      return getLectureId();

    case LECTURE_NAME:
      return getLectureName();

    case DESCRIPTION:
      return getDescription();

    case IMAGE_VERSION_ID:
      return getImageVersionId();

    case IMAGE_BASE_ID:
      return getImageBaseId();

    case AUTO_UPDATE:
      return isAutoUpdate();

    case IS_ENABLED:
      return isIsEnabled();

    case START_TIME:
      return getStartTime();

    case END_TIME:
      return getEndTime();

    case LAST_USED:
      return getLastUsed();

    case USE_COUNT:
      return getUseCount();

    case CREATE_TIME:
      return getCreateTime();

    case UPDATE_TIME:
      return getUpdateTime();

    case OWNER_ID:
      return getOwnerId();

    case UPDATER_ID:
      return getUpdaterId();

    case RUNSCRIPT:
      return getRunscript();

    case NICS:
      return getNics();

    case ALLOWED_USERS:
      return getAllowedUsers();

    case NETWORK_EXCEPTIONS:
      return getNetworkExceptions();

    case IS_EXAM:
      return isIsExam();

    case HAS_INTERNET_ACCESS:
      return isHasInternetAccess();

    case DEFAULT_PERMISSIONS:
      return getDefaultPermissions();

    case USER_PERMISSIONS:
      return getUserPermissions();

    case LOCATION_IDS:
      return getLocationIds();

    case LIMIT_TO_LOCATIONS:
      return isLimitToLocations();

    case LIMIT_TO_ALLOWED_USERS:
      return isLimitToAllowedUsers();

    case HAS_USB_ACCESS:
      return isHasUsbAccess();

    case NETWORK_SHARES:
      return getNetworkShares();

    }
    throw new IllegalStateException();
  }

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

    switch (field) {
    case LECTURE_ID:
      return isSetLectureId();
    case LECTURE_NAME:
      return isSetLectureName();
    case DESCRIPTION:
      return isSetDescription();
    case IMAGE_VERSION_ID:
      return isSetImageVersionId();
    case IMAGE_BASE_ID:
      return isSetImageBaseId();
    case AUTO_UPDATE:
      return isSetAutoUpdate();
    case IS_ENABLED:
      return isSetIsEnabled();
    case START_TIME:
      return isSetStartTime();
    case END_TIME:
      return isSetEndTime();
    case LAST_USED:
      return isSetLastUsed();
    case USE_COUNT:
      return isSetUseCount();
    case CREATE_TIME:
      return isSetCreateTime();
    case UPDATE_TIME:
      return isSetUpdateTime();
    case OWNER_ID:
      return isSetOwnerId();
    case UPDATER_ID:
      return isSetUpdaterId();
    case RUNSCRIPT:
      return isSetRunscript();
    case NICS:
      return isSetNics();
    case ALLOWED_USERS:
      return isSetAllowedUsers();
    case NETWORK_EXCEPTIONS:
      return isSetNetworkExceptions();
    case IS_EXAM:
      return isSetIsExam();
    case HAS_INTERNET_ACCESS:
      return isSetHasInternetAccess();
    case DEFAULT_PERMISSIONS:
      return isSetDefaultPermissions();
    case USER_PERMISSIONS:
      return isSetUserPermissions();
    case LOCATION_IDS:
      return isSetLocationIds();
    case LIMIT_TO_LOCATIONS:
      return isSetLimitToLocations();
    case LIMIT_TO_ALLOWED_USERS:
      return isSetLimitToAllowedUsers();
    case HAS_USB_ACCESS:
      return isSetHasUsbAccess();
    case NETWORK_SHARES:
      return isSetNetworkShares();
    }
    throw new IllegalStateException();
  }

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

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

    boolean this_present_lectureId = true && this.isSetLectureId();
    boolean that_present_lectureId = true && that.isSetLectureId();
    if (this_present_lectureId || that_present_lectureId) {
      if (!(this_present_lectureId && that_present_lectureId))
        return false;
      if (!this.lectureId.equals(that.lectureId))
        return false;
    }

    boolean this_present_lectureName = true && this.isSetLectureName();
    boolean that_present_lectureName = true && that.isSetLectureName();
    if (this_present_lectureName || that_present_lectureName) {
      if (!(this_present_lectureName && that_present_lectureName))
        return false;
      if (!this.lectureName.equals(that.lectureName))
        return false;
    }

    boolean this_present_description = true && this.isSetDescription();
    boolean that_present_description = true && that.isSetDescription();
    if (this_present_description || that_present_description) {
      if (!(this_present_description && that_present_description))
        return false;
      if (!this.description.equals(that.description))
        return false;
    }

    boolean this_present_imageVersionId = true && this.isSetImageVersionId();
    boolean that_present_imageVersionId = true && that.isSetImageVersionId();
    if (this_present_imageVersionId || that_present_imageVersionId) {
      if (!(this_present_imageVersionId && that_present_imageVersionId))
        return false;
      if (!this.imageVersionId.equals(that.imageVersionId))
        return false;
    }

    boolean this_present_imageBaseId = true && this.isSetImageBaseId();
    boolean that_present_imageBaseId = true && that.isSetImageBaseId();
    if (this_present_imageBaseId || that_present_imageBaseId) {
      if (!(this_present_imageBaseId && that_present_imageBaseId))
        return false;
      if (!this.imageBaseId.equals(that.imageBaseId))
        return false;
    }

    boolean this_present_autoUpdate = true;
    boolean that_present_autoUpdate = true;
    if (this_present_autoUpdate || that_present_autoUpdate) {
      if (!(this_present_autoUpdate && that_present_autoUpdate))
        return false;
      if (this.autoUpdate != that.autoUpdate)
        return false;
    }

    boolean this_present_isEnabled = true;
    boolean that_present_isEnabled = true;
    if (this_present_isEnabled || that_present_isEnabled) {
      if (!(this_present_isEnabled && that_present_isEnabled))
        return false;
      if (this.isEnabled != that.isEnabled)
        return false;
    }

    boolean this_present_startTime = true;
    boolean that_present_startTime = true;
    if (this_present_startTime || that_present_startTime) {
      if (!(this_present_startTime && that_present_startTime))
        return false;
      if (this.startTime != that.startTime)
        return false;
    }

    boolean this_present_endTime = true;
    boolean that_present_endTime = true;
    if (this_present_endTime || that_present_endTime) {
      if (!(this_present_endTime && that_present_endTime))
        return false;
      if (this.endTime != that.endTime)
        return false;
    }

    boolean this_present_lastUsed = true;
    boolean that_present_lastUsed = true;
    if (this_present_lastUsed || that_present_lastUsed) {
      if (!(this_present_lastUsed && that_present_lastUsed))
        return false;
      if (this.lastUsed != that.lastUsed)
        return false;
    }

    boolean this_present_useCount = true;
    boolean that_present_useCount = true;
    if (this_present_useCount || that_present_useCount) {
      if (!(this_present_useCount && that_present_useCount))
        return false;
      if (this.useCount != that.useCount)
        return false;
    }

    boolean this_present_createTime = true;
    boolean that_present_createTime = true;
    if (this_present_createTime || that_present_createTime) {
      if (!(this_present_createTime && that_present_createTime))
        return false;
      if (this.createTime != that.createTime)
        return false;
    }

    boolean this_present_updateTime = true;
    boolean that_present_updateTime = true;
    if (this_present_updateTime || that_present_updateTime) {
      if (!(this_present_updateTime && that_present_updateTime))
        return false;
      if (this.updateTime != that.updateTime)
        return false;
    }

    boolean this_present_ownerId = true && this.isSetOwnerId();
    boolean that_present_ownerId = true && that.isSetOwnerId();
    if (this_present_ownerId || that_present_ownerId) {
      if (!(this_present_ownerId && that_present_ownerId))
        return false;
      if (!this.ownerId.equals(that.ownerId))
        return false;
    }

    boolean this_present_updaterId = true && this.isSetUpdaterId();
    boolean that_present_updaterId = true && that.isSetUpdaterId();
    if (this_present_updaterId || that_present_updaterId) {
      if (!(this_present_updaterId && that_present_updaterId))
        return false;
      if (!this.updaterId.equals(that.updaterId))
        return false;
    }

    boolean this_present_runscript = true && this.isSetRunscript();
    boolean that_present_runscript = true && that.isSetRunscript();
    if (this_present_runscript || that_present_runscript) {
      if (!(this_present_runscript && that_present_runscript))
        return false;
      if (!this.runscript.equals(that.runscript))
        return false;
    }

    boolean this_present_nics = true && this.isSetNics();
    boolean that_present_nics = true && that.isSetNics();
    if (this_present_nics || that_present_nics) {
      if (!(this_present_nics && that_present_nics))
        return false;
      if (!this.nics.equals(that.nics))
        return false;
    }

    boolean this_present_allowedUsers = true && this.isSetAllowedUsers();
    boolean that_present_allowedUsers = true && that.isSetAllowedUsers();
    if (this_present_allowedUsers || that_present_allowedUsers) {
      if (!(this_present_allowedUsers && that_present_allowedUsers))
        return false;
      if (!this.allowedUsers.equals(that.allowedUsers))
        return false;
    }

    boolean this_present_networkExceptions = true && this.isSetNetworkExceptions();
    boolean that_present_networkExceptions = true && that.isSetNetworkExceptions();
    if (this_present_networkExceptions || that_present_networkExceptions) {
      if (!(this_present_networkExceptions && that_present_networkExceptions))
        return false;
      if (!this.networkExceptions.equals(that.networkExceptions))
        return false;
    }

    boolean this_present_isExam = true;
    boolean that_present_isExam = true;
    if (this_present_isExam || that_present_isExam) {
      if (!(this_present_isExam && that_present_isExam))
        return false;
      if (this.isExam != that.isExam)
        return false;
    }

    boolean this_present_hasInternetAccess = true;
    boolean that_present_hasInternetAccess = true;
    if (this_present_hasInternetAccess || that_present_hasInternetAccess) {
      if (!(this_present_hasInternetAccess && that_present_hasInternetAccess))
        return false;
      if (this.hasInternetAccess != that.hasInternetAccess)
        return false;
    }

    boolean this_present_defaultPermissions = true && this.isSetDefaultPermissions();
    boolean that_present_defaultPermissions = true && that.isSetDefaultPermissions();
    if (this_present_defaultPermissions || that_present_defaultPermissions) {
      if (!(this_present_defaultPermissions && that_present_defaultPermissions))
        return false;
      if (!this.defaultPermissions.equals(that.defaultPermissions))
        return false;
    }

    boolean this_present_userPermissions = true && this.isSetUserPermissions();
    boolean that_present_userPermissions = true && that.isSetUserPermissions();
    if (this_present_userPermissions || that_present_userPermissions) {
      if (!(this_present_userPermissions && that_present_userPermissions))
        return false;
      if (!this.userPermissions.equals(that.userPermissions))
        return false;
    }

    boolean this_present_locationIds = true && this.isSetLocationIds();
    boolean that_present_locationIds = true && that.isSetLocationIds();
    if (this_present_locationIds || that_present_locationIds) {
      if (!(this_present_locationIds && that_present_locationIds))
        return false;
      if (!this.locationIds.equals(that.locationIds))
        return false;
    }

    boolean this_present_limitToLocations = true;
    boolean that_present_limitToLocations = true;
    if (this_present_limitToLocations || that_present_limitToLocations) {
      if (!(this_present_limitToLocations && that_present_limitToLocations))
        return false;
      if (this.limitToLocations != that.limitToLocations)
        return false;
    }

    boolean this_present_limitToAllowedUsers = true;
    boolean that_present_limitToAllowedUsers = true;
    if (this_present_limitToAllowedUsers || that_present_limitToAllowedUsers) {
      if (!(this_present_limitToAllowedUsers && that_present_limitToAllowedUsers))
        return false;
      if (this.limitToAllowedUsers != that.limitToAllowedUsers)
        return false;
    }

    boolean this_present_hasUsbAccess = true;
    boolean that_present_hasUsbAccess = true;
    if (this_present_hasUsbAccess || that_present_hasUsbAccess) {
      if (!(this_present_hasUsbAccess && that_present_hasUsbAccess))
        return false;
      if (this.hasUsbAccess != that.hasUsbAccess)
        return false;
    }

    boolean this_present_networkShares = true && this.isSetNetworkShares();
    boolean that_present_networkShares = true && that.isSetNetworkShares();
    if (this_present_networkShares || that_present_networkShares) {
      if (!(this_present_networkShares && that_present_networkShares))
        return false;
      if (!this.networkShares.equals(that.networkShares))
        return false;
    }

    return true;
  }

  @Override
  public int hashCode() {
    List<Object> list = new ArrayList<Object>();

    boolean present_lectureId = true && (isSetLectureId());
    list.add(present_lectureId);
    if (present_lectureId)
      list.add(lectureId);

    boolean present_lectureName = true && (isSetLectureName());
    list.add(present_lectureName);
    if (present_lectureName)
      list.add(lectureName);

    boolean present_description = true && (isSetDescription());
    list.add(present_description);
    if (present_description)
      list.add(description);

    boolean present_imageVersionId = true && (isSetImageVersionId());
    list.add(present_imageVersionId);
    if (present_imageVersionId)
      list.add(imageVersionId);

    boolean present_imageBaseId = true && (isSetImageBaseId());
    list.add(present_imageBaseId);
    if (present_imageBaseId)
      list.add(imageBaseId);

    boolean present_autoUpdate = true;
    list.add(present_autoUpdate);
    if (present_autoUpdate)
      list.add(autoUpdate);

    boolean present_isEnabled = true;
    list.add(present_isEnabled);
    if (present_isEnabled)
      list.add(isEnabled);

    boolean present_startTime = true;
    list.add(present_startTime);
    if (present_startTime)
      list.add(startTime);

    boolean present_endTime = true;
    list.add(present_endTime);
    if (present_endTime)
      list.add(endTime);

    boolean present_lastUsed = true;
    list.add(present_lastUsed);
    if (present_lastUsed)
      list.add(lastUsed);

    boolean present_useCount = true;
    list.add(present_useCount);
    if (present_useCount)
      list.add(useCount);

    boolean present_createTime = true;
    list.add(present_createTime);
    if (present_createTime)
      list.add(createTime);

    boolean present_updateTime = true;
    list.add(present_updateTime);
    if (present_updateTime)
      list.add(updateTime);

    boolean present_ownerId = true && (isSetOwnerId());
    list.add(present_ownerId);
    if (present_ownerId)
      list.add(ownerId);

    boolean present_updaterId = true && (isSetUpdaterId());
    list.add(present_updaterId);
    if (present_updaterId)
      list.add(updaterId);

    boolean present_runscript = true && (isSetRunscript());
    list.add(present_runscript);
    if (present_runscript)
      list.add(runscript);

    boolean present_nics = true && (isSetNics());
    list.add(present_nics);
    if (present_nics)
      list.add(nics);

    boolean present_allowedUsers = true && (isSetAllowedUsers());
    list.add(present_allowedUsers);
    if (present_allowedUsers)
      list.add(allowedUsers);

    boolean present_networkExceptions = true && (isSetNetworkExceptions());
    list.add(present_networkExceptions);
    if (present_networkExceptions)
      list.add(networkExceptions);

    boolean present_isExam = true;
    list.add(present_isExam);
    if (present_isExam)
      list.add(isExam);

    boolean present_hasInternetAccess = true;
    list.add(present_hasInternetAccess);
    if (present_hasInternetAccess)
      list.add(hasInternetAccess);

    boolean present_defaultPermissions = true && (isSetDefaultPermissions());
    list.add(present_defaultPermissions);
    if (present_defaultPermissions)
      list.add(defaultPermissions);

    boolean present_userPermissions = true && (isSetUserPermissions());
    list.add(present_userPermissions);
    if (present_userPermissions)
      list.add(userPermissions);

    boolean present_locationIds = true && (isSetLocationIds());
    list.add(present_locationIds);
    if (present_locationIds)
      list.add(locationIds);

    boolean present_limitToLocations = true;
    list.add(present_limitToLocations);
    if (present_limitToLocations)
      list.add(limitToLocations);

    boolean present_limitToAllowedUsers = true;
    list.add(present_limitToAllowedUsers);
    if (present_limitToAllowedUsers)
      list.add(limitToAllowedUsers);

    boolean present_hasUsbAccess = true;
    list.add(present_hasUsbAccess);
    if (present_hasUsbAccess)
      list.add(hasUsbAccess);

    boolean present_networkShares = true && (isSetNetworkShares());
    list.add(present_networkShares);
    if (present_networkShares)
      list.add(networkShares);

    return list.hashCode();
  }

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

    int lastComparison = 0;

    lastComparison = Boolean.valueOf(isSetLectureId()).compareTo(other.isSetLectureId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLectureId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureId, other.lectureId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetLectureName()).compareTo(other.isSetLectureName());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLectureName()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lectureName, other.lectureName);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetDescription()).compareTo(other.isSetDescription());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetDescription()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.description, other.description);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetImageVersionId()).compareTo(other.isSetImageVersionId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetImageVersionId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageVersionId, other.imageVersionId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetImageBaseId()).compareTo(other.isSetImageBaseId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetImageBaseId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.imageBaseId, other.imageBaseId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetAutoUpdate()).compareTo(other.isSetAutoUpdate());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetAutoUpdate()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.autoUpdate, other.autoUpdate);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetIsEnabled()).compareTo(other.isSetIsEnabled());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetIsEnabled()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isEnabled, other.isEnabled);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetStartTime()).compareTo(other.isSetStartTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetStartTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.startTime, other.startTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetEndTime()).compareTo(other.isSetEndTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetEndTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.endTime, other.endTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetLastUsed()).compareTo(other.isSetLastUsed());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLastUsed()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.lastUsed, other.lastUsed);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetUseCount()).compareTo(other.isSetUseCount());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetUseCount()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.useCount, other.useCount);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetCreateTime()).compareTo(other.isSetCreateTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetCreateTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.createTime, other.createTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetUpdateTime()).compareTo(other.isSetUpdateTime());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetUpdateTime()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updateTime, other.updateTime);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetOwnerId()).compareTo(other.isSetOwnerId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetOwnerId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.ownerId, other.ownerId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetUpdaterId()).compareTo(other.isSetUpdaterId());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetUpdaterId()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.updaterId, other.updaterId);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetRunscript()).compareTo(other.isSetRunscript());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetRunscript()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.runscript, other.runscript);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetNics()).compareTo(other.isSetNics());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNics()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.nics, other.nics);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetAllowedUsers()).compareTo(other.isSetAllowedUsers());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetAllowedUsers()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.allowedUsers, other.allowedUsers);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetNetworkExceptions()).compareTo(other.isSetNetworkExceptions());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNetworkExceptions()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.networkExceptions, other.networkExceptions);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetIsExam()).compareTo(other.isSetIsExam());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetIsExam()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.isExam, other.isExam);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetHasInternetAccess()).compareTo(other.isSetHasInternetAccess());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetHasInternetAccess()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.hasInternetAccess, other.hasInternetAccess);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetDefaultPermissions()).compareTo(other.isSetDefaultPermissions());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetDefaultPermissions()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.defaultPermissions, other.defaultPermissions);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetUserPermissions()).compareTo(other.isSetUserPermissions());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetUserPermissions()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userPermissions, other.userPermissions);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetLocationIds()).compareTo(other.isSetLocationIds());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLocationIds()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.locationIds, other.locationIds);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetLimitToLocations()).compareTo(other.isSetLimitToLocations());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLimitToLocations()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limitToLocations, other.limitToLocations);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetLimitToAllowedUsers()).compareTo(other.isSetLimitToAllowedUsers());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetLimitToAllowedUsers()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.limitToAllowedUsers, other.limitToAllowedUsers);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetHasUsbAccess()).compareTo(other.isSetHasUsbAccess());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetHasUsbAccess()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.hasUsbAccess, other.hasUsbAccess);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    lastComparison = Boolean.valueOf(isSetNetworkShares()).compareTo(other.isSetNetworkShares());
    if (lastComparison != 0) {
      return lastComparison;
    }
    if (isSetNetworkShares()) {
      lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.networkShares, other.networkShares);
      if (lastComparison != 0) {
        return lastComparison;
      }
    }
    return 0;
  }

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

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

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

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

    sb.append("lectureId:");
    if (this.lectureId == null) {
      sb.append("null");
    } else {
      sb.append(this.lectureId);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("lectureName:");
    if (this.lectureName == null) {
      sb.append("null");
    } else {
      sb.append(this.lectureName);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("description:");
    if (this.description == null) {
      sb.append("null");
    } else {
      sb.append(this.description);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("imageVersionId:");
    if (this.imageVersionId == null) {
      sb.append("null");
    } else {
      sb.append(this.imageVersionId);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("imageBaseId:");
    if (this.imageBaseId == null) {
      sb.append("null");
    } else {
      sb.append(this.imageBaseId);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("autoUpdate:");
    sb.append(this.autoUpdate);
    first = false;
    if (!first) sb.append(", ");
    sb.append("isEnabled:");
    sb.append(this.isEnabled);
    first = false;
    if (!first) sb.append(", ");
    sb.append("startTime:");
    sb.append(this.startTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("endTime:");
    sb.append(this.endTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("lastUsed:");
    sb.append(this.lastUsed);
    first = false;
    if (!first) sb.append(", ");
    sb.append("useCount:");
    sb.append(this.useCount);
    first = false;
    if (!first) sb.append(", ");
    sb.append("createTime:");
    sb.append(this.createTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("updateTime:");
    sb.append(this.updateTime);
    first = false;
    if (!first) sb.append(", ");
    sb.append("ownerId:");
    if (this.ownerId == null) {
      sb.append("null");
    } else {
      sb.append(this.ownerId);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("updaterId:");
    if (this.updaterId == null) {
      sb.append("null");
    } else {
      sb.append(this.updaterId);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("runscript:");
    if (this.runscript == null) {
      sb.append("null");
    } else {
      sb.append(this.runscript);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("nics:");
    if (this.nics == null) {
      sb.append("null");
    } else {
      sb.append(this.nics);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("allowedUsers:");
    if (this.allowedUsers == null) {
      sb.append("null");
    } else {
      sb.append(this.allowedUsers);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("networkExceptions:");
    if (this.networkExceptions == null) {
      sb.append("null");
    } else {
      sb.append(this.networkExceptions);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("isExam:");
    sb.append(this.isExam);
    first = false;
    if (!first) sb.append(", ");
    sb.append("hasInternetAccess:");
    sb.append(this.hasInternetAccess);
    first = false;
    if (!first) sb.append(", ");
    sb.append("defaultPermissions:");
    if (this.defaultPermissions == null) {
      sb.append("null");
    } else {
      sb.append(this.defaultPermissions);
    }
    first = false;
    if (isSetUserPermissions()) {
      if (!first) sb.append(", ");
      sb.append("userPermissions:");
      if (this.userPermissions == null) {
        sb.append("null");
      } else {
        sb.append(this.userPermissions);
      }
      first = false;
    }
    if (!first) sb.append(", ");
    sb.append("locationIds:");
    if (this.locationIds == null) {
      sb.append("null");
    } else {
      sb.append(this.locationIds);
    }
    first = false;
    if (!first) sb.append(", ");
    sb.append("limitToLocations:");
    sb.append(this.limitToLocations);
    first = false;
    if (!first) sb.append(", ");
    sb.append("limitToAllowedUsers:");
    sb.append(this.limitToAllowedUsers);
    first = false;
    if (!first) sb.append(", ");
    sb.append("hasUsbAccess:");
    sb.append(this.hasUsbAccess);
    first = false;
    if (isSetNetworkShares()) {
      if (!first) sb.append(", ");
      sb.append("networkShares:");
      if (this.networkShares == null) {
        sb.append("null");
      } else {
        sb.append(this.networkShares);
      }
      first = false;
    }
    sb.append(")");
    return sb.toString();
  }

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

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

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

  private static class LectureReadStandardSchemeFactory implements SchemeFactory {
    public LectureReadStandardScheme getScheme() {
      return new LectureReadStandardScheme();
    }
  }

  private static class LectureReadStandardScheme extends StandardScheme<LectureRead> {

    public void read(org.apache.thrift.protocol.TProtocol iprot, LectureRead struct) throws org.apache.thrift.TException {
      org.apache.thrift.protocol.TField schemeField;
      iprot.readStructBegin();
      while (true)
      {
        schemeField = iprot.readFieldBegin();
        if (schemeField.type == org.apache.thrift.protocol.TType.STOP) { 
          break;
        }
        switch (schemeField.id) {
          case 1: // LECTURE_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.lectureId = iprot.readString();
              struct.setLectureIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 2: // LECTURE_NAME
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.lectureName = iprot.readString();
              struct.setLectureNameIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 3: // DESCRIPTION
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.description = iprot.readString();
              struct.setDescriptionIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 23: // IMAGE_VERSION_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.imageVersionId = iprot.readString();
              struct.setImageVersionIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 24: // IMAGE_BASE_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.imageBaseId = iprot.readString();
              struct.setImageBaseIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 5: // AUTO_UPDATE
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.autoUpdate = iprot.readBool();
              struct.setAutoUpdateIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 6: // IS_ENABLED
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.isEnabled = iprot.readBool();
              struct.setIsEnabledIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 7: // START_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.startTime = iprot.readI64();
              struct.setStartTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 8: // END_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.endTime = iprot.readI64();
              struct.setEndTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 9: // LAST_USED
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.lastUsed = iprot.readI64();
              struct.setLastUsedIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 10: // USE_COUNT
            if (schemeField.type == org.apache.thrift.protocol.TType.I32) {
              struct.useCount = iprot.readI32();
              struct.setUseCountIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 20: // CREATE_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.createTime = iprot.readI64();
              struct.setCreateTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 21: // UPDATE_TIME
            if (schemeField.type == org.apache.thrift.protocol.TType.I64) {
              struct.updateTime = iprot.readI64();
              struct.setUpdateTimeIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 11: // OWNER_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.ownerId = iprot.readString();
              struct.setOwnerIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 12: // UPDATER_ID
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.updaterId = iprot.readString();
              struct.setUpdaterIdIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 13: // RUNSCRIPT
            if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
              struct.runscript = iprot.readString();
              struct.setRunscriptIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 14: // NICS
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list138 = iprot.readListBegin();
                struct.nics = new ArrayList<String>(_list138.size);
                String _elem139;
                for (int _i140 = 0; _i140 < _list138.size; ++_i140)
                {
                  _elem139 = iprot.readString();
                  struct.nics.add(_elem139);
                }
                iprot.readListEnd();
              }
              struct.setNicsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 15: // ALLOWED_USERS
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list141 = iprot.readListBegin();
                struct.allowedUsers = new ArrayList<String>(_list141.size);
                String _elem142;
                for (int _i143 = 0; _i143 < _list141.size; ++_i143)
                {
                  _elem142 = iprot.readString();
                  struct.allowedUsers.add(_elem142);
                }
                iprot.readListEnd();
              }
              struct.setAllowedUsersIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 16: // NETWORK_EXCEPTIONS
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list144 = iprot.readListBegin();
                struct.networkExceptions = new ArrayList<NetRule>(_list144.size);
                NetRule _elem145;
                for (int _i146 = 0; _i146 < _list144.size; ++_i146)
                {
                  _elem145 = new NetRule();
                  _elem145.read(iprot);
                  struct.networkExceptions.add(_elem145);
                }
                iprot.readListEnd();
              }
              struct.setNetworkExceptionsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 17: // IS_EXAM
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.isExam = iprot.readBool();
              struct.setIsExamIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 18: // HAS_INTERNET_ACCESS
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.hasInternetAccess = iprot.readBool();
              struct.setHasInternetAccessIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 19: // DEFAULT_PERMISSIONS
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.defaultPermissions = new LecturePermissions();
              struct.defaultPermissions.read(iprot);
              struct.setDefaultPermissionsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 22: // USER_PERMISSIONS
            if (schemeField.type == org.apache.thrift.protocol.TType.STRUCT) {
              struct.userPermissions = new LecturePermissions();
              struct.userPermissions.read(iprot);
              struct.setUserPermissionsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 25: // LOCATION_IDS
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list147 = iprot.readListBegin();
                struct.locationIds = new ArrayList<Integer>(_list147.size);
                int _elem148;
                for (int _i149 = 0; _i149 < _list147.size; ++_i149)
                {
                  _elem148 = iprot.readI32();
                  struct.locationIds.add(_elem148);
                }
                iprot.readListEnd();
              }
              struct.setLocationIdsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 26: // LIMIT_TO_LOCATIONS
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.limitToLocations = iprot.readBool();
              struct.setLimitToLocationsIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 27: // LIMIT_TO_ALLOWED_USERS
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.limitToAllowedUsers = iprot.readBool();
              struct.setLimitToAllowedUsersIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 28: // HAS_USB_ACCESS
            if (schemeField.type == org.apache.thrift.protocol.TType.BOOL) {
              struct.hasUsbAccess = iprot.readBool();
              struct.setHasUsbAccessIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          case 29: // NETWORK_SHARES
            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
              {
                org.apache.thrift.protocol.TList _list150 = iprot.readListBegin();
                struct.networkShares = new ArrayList<NetShare>(_list150.size);
                NetShare _elem151;
                for (int _i152 = 0; _i152 < _list150.size; ++_i152)
                {
                  _elem151 = new NetShare();
                  _elem151.read(iprot);
                  struct.networkShares.add(_elem151);
                }
                iprot.readListEnd();
              }
              struct.setNetworkSharesIsSet(true);
            } else { 
              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
            }
            break;
          default:
            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type);
        }
        iprot.readFieldEnd();
      }
      iprot.readStructEnd();

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

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

      oprot.writeStructBegin(STRUCT_DESC);
      if (struct.lectureId != null) {
        oprot.writeFieldBegin(LECTURE_ID_FIELD_DESC);
        oprot.writeString(struct.lectureId);
        oprot.writeFieldEnd();
      }
      if (struct.lectureName != null) {
        oprot.writeFieldBegin(LECTURE_NAME_FIELD_DESC);
        oprot.writeString(struct.lectureName);
        oprot.writeFieldEnd();
      }
      if (struct.description != null) {
        oprot.writeFieldBegin(DESCRIPTION_FIELD_DESC);
        oprot.writeString(struct.description);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(AUTO_UPDATE_FIELD_DESC);
      oprot.writeBool(struct.autoUpdate);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(IS_ENABLED_FIELD_DESC);
      oprot.writeBool(struct.isEnabled);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(START_TIME_FIELD_DESC);
      oprot.writeI64(struct.startTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(END_TIME_FIELD_DESC);
      oprot.writeI64(struct.endTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LAST_USED_FIELD_DESC);
      oprot.writeI64(struct.lastUsed);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(USE_COUNT_FIELD_DESC);
      oprot.writeI32(struct.useCount);
      oprot.writeFieldEnd();
      if (struct.ownerId != null) {
        oprot.writeFieldBegin(OWNER_ID_FIELD_DESC);
        oprot.writeString(struct.ownerId);
        oprot.writeFieldEnd();
      }
      if (struct.updaterId != null) {
        oprot.writeFieldBegin(UPDATER_ID_FIELD_DESC);
        oprot.writeString(struct.updaterId);
        oprot.writeFieldEnd();
      }
      if (struct.runscript != null) {
        oprot.writeFieldBegin(RUNSCRIPT_FIELD_DESC);
        oprot.writeString(struct.runscript);
        oprot.writeFieldEnd();
      }
      if (struct.nics != null) {
        oprot.writeFieldBegin(NICS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.nics.size()));
          for (String _iter153 : struct.nics)
          {
            oprot.writeString(_iter153);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (struct.allowedUsers != null) {
        oprot.writeFieldBegin(ALLOWED_USERS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, struct.allowedUsers.size()));
          for (String _iter154 : struct.allowedUsers)
          {
            oprot.writeString(_iter154);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      if (struct.networkExceptions != null) {
        oprot.writeFieldBegin(NETWORK_EXCEPTIONS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.networkExceptions.size()));
          for (NetRule _iter155 : struct.networkExceptions)
          {
            _iter155.write(oprot);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(IS_EXAM_FIELD_DESC);
      oprot.writeBool(struct.isExam);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(HAS_INTERNET_ACCESS_FIELD_DESC);
      oprot.writeBool(struct.hasInternetAccess);
      oprot.writeFieldEnd();
      if (struct.defaultPermissions != null) {
        oprot.writeFieldBegin(DEFAULT_PERMISSIONS_FIELD_DESC);
        struct.defaultPermissions.write(oprot);
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(CREATE_TIME_FIELD_DESC);
      oprot.writeI64(struct.createTime);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(UPDATE_TIME_FIELD_DESC);
      oprot.writeI64(struct.updateTime);
      oprot.writeFieldEnd();
      if (struct.userPermissions != null) {
        if (struct.isSetUserPermissions()) {
          oprot.writeFieldBegin(USER_PERMISSIONS_FIELD_DESC);
          struct.userPermissions.write(oprot);
          oprot.writeFieldEnd();
        }
      }
      if (struct.imageVersionId != null) {
        oprot.writeFieldBegin(IMAGE_VERSION_ID_FIELD_DESC);
        oprot.writeString(struct.imageVersionId);
        oprot.writeFieldEnd();
      }
      if (struct.imageBaseId != null) {
        oprot.writeFieldBegin(IMAGE_BASE_ID_FIELD_DESC);
        oprot.writeString(struct.imageBaseId);
        oprot.writeFieldEnd();
      }
      if (struct.locationIds != null) {
        oprot.writeFieldBegin(LOCATION_IDS_FIELD_DESC);
        {
          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, struct.locationIds.size()));
          for (int _iter156 : struct.locationIds)
          {
            oprot.writeI32(_iter156);
          }
          oprot.writeListEnd();
        }
        oprot.writeFieldEnd();
      }
      oprot.writeFieldBegin(LIMIT_TO_LOCATIONS_FIELD_DESC);
      oprot.writeBool(struct.limitToLocations);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(LIMIT_TO_ALLOWED_USERS_FIELD_DESC);
      oprot.writeBool(struct.limitToAllowedUsers);
      oprot.writeFieldEnd();
      oprot.writeFieldBegin(HAS_USB_ACCESS_FIELD_DESC);
      oprot.writeBool(struct.hasUsbAccess);
      oprot.writeFieldEnd();
      if (struct.networkShares != null) {
        if (struct.isSetNetworkShares()) {
          oprot.writeFieldBegin(NETWORK_SHARES_FIELD_DESC);
          {
            oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, struct.networkShares.size()));
            for (NetShare _iter157 : struct.networkShares)
            {
              _iter157.write(oprot);
            }
            oprot.writeListEnd();
          }
          oprot.writeFieldEnd();
        }
      }
      oprot.writeFieldStop();
      oprot.writeStructEnd();
    }

  }

  private static class LectureReadTupleSchemeFactory implements SchemeFactory {
    public LectureReadTupleScheme getScheme() {
      return new LectureReadTupleScheme();
    }
  }

  private static class LectureReadTupleScheme extends TupleScheme<LectureRead> {

    @Override
    public void write(org.apache.thrift.protocol.TProtocol prot, LectureRead struct) throws org.apache.thrift.TException {
      TTupleProtocol oprot = (TTupleProtocol) prot;
      BitSet optionals = new BitSet();
      if (struct.isSetLectureId()) {
        optionals.set(0);
      }
      if (struct.isSetLectureName()) {
        optionals.set(1);
      }
      if (struct.isSetDescription()) {
        optionals.set(2);
      }
      if (struct.isSetImageVersionId()) {
        optionals.set(3);
      }
      if (struct.isSetImageBaseId()) {
        optionals.set(4);
      }
      if (struct.isSetAutoUpdate()) {
        optionals.set(5);
      }
      if (struct.isSetIsEnabled()) {
        optionals.set(6);
      }
      if (struct.isSetStartTime()) {
        optionals.set(7);
      }
      if (struct.isSetEndTime()) {
        optionals.set(8);
      }
      if (struct.isSetLastUsed()) {
        optionals.set(9);
      }
      if (struct.isSetUseCount()) {
        optionals.set(10);
      }
      if (struct.isSetCreateTime()) {
        optionals.set(11);
      }
      if (struct.isSetUpdateTime()) {
        optionals.set(12);
      }
      if (struct.isSetOwnerId()) {
        optionals.set(13);
      }
      if (struct.isSetUpdaterId()) {
        optionals.set(14);
      }
      if (struct.isSetRunscript()) {
        optionals.set(15);
      }
      if (struct.isSetNics()) {
        optionals.set(16);
      }
      if (struct.isSetAllowedUsers()) {
        optionals.set(17);
      }
      if (struct.isSetNetworkExceptions()) {
        optionals.set(18);
      }
      if (struct.isSetIsExam()) {
        optionals.set(19);
      }
      if (struct.isSetHasInternetAccess()) {
        optionals.set(20);
      }
      if (struct.isSetDefaultPermissions()) {
        optionals.set(21);
      }
      if (struct.isSetUserPermissions()) {
        optionals.set(22);
      }
      if (struct.isSetLocationIds()) {
        optionals.set(23);
      }
      if (struct.isSetLimitToLocations()) {
        optionals.set(24);
      }
      if (struct.isSetLimitToAllowedUsers()) {
        optionals.set(25);
      }
      if (struct.isSetHasUsbAccess()) {
        optionals.set(26);
      }
      if (struct.isSetNetworkShares()) {
        optionals.set(27);
      }
      oprot.writeBitSet(optionals, 28);
      if (struct.isSetLectureId()) {
        oprot.writeString(struct.lectureId);
      }
      if (struct.isSetLectureName()) {
        oprot.writeString(struct.lectureName);
      }
      if (struct.isSetDescription()) {
        oprot.writeString(struct.description);
      }
      if (struct.isSetImageVersionId()) {
        oprot.writeString(struct.imageVersionId);
      }
      if (struct.isSetImageBaseId()) {
        oprot.writeString(struct.imageBaseId);
      }
      if (struct.isSetAutoUpdate()) {
        oprot.writeBool(struct.autoUpdate);
      }
      if (struct.isSetIsEnabled()) {
        oprot.writeBool(struct.isEnabled);
      }
      if (struct.isSetStartTime()) {
        oprot.writeI64(struct.startTime);
      }
      if (struct.isSetEndTime()) {
        oprot.writeI64(struct.endTime);
      }
      if (struct.isSetLastUsed()) {
        oprot.writeI64(struct.lastUsed);
      }
      if (struct.isSetUseCount()) {
        oprot.writeI32(struct.useCount);
      }
      if (struct.isSetCreateTime()) {
        oprot.writeI64(struct.createTime);
      }
      if (struct.isSetUpdateTime()) {
        oprot.writeI64(struct.updateTime);
      }
      if (struct.isSetOwnerId()) {
        oprot.writeString(struct.ownerId);
      }
      if (struct.isSetUpdaterId()) {
        oprot.writeString(struct.updaterId);
      }
      if (struct.isSetRunscript()) {
        oprot.writeString(struct.runscript);
      }
      if (struct.isSetNics()) {
        {
          oprot.writeI32(struct.nics.size());
          for (String _iter158 : struct.nics)
          {
            oprot.writeString(_iter158);
          }
        }
      }
      if (struct.isSetAllowedUsers()) {
        {
          oprot.writeI32(struct.allowedUsers.size());
          for (String _iter159 : struct.allowedUsers)
          {
            oprot.writeString(_iter159);
          }
        }
      }
      if (struct.isSetNetworkExceptions()) {
        {
          oprot.writeI32(struct.networkExceptions.size());
          for (NetRule _iter160 : struct.networkExceptions)
          {
            _iter160.write(oprot);
          }
        }
      }
      if (struct.isSetIsExam()) {
        oprot.writeBool(struct.isExam);
      }
      if (struct.isSetHasInternetAccess()) {
        oprot.writeBool(struct.hasInternetAccess);
      }
      if (struct.isSetDefaultPermissions()) {
        struct.defaultPermissions.write(oprot);
      }
      if (struct.isSetUserPermissions()) {
        struct.userPermissions.write(oprot);
      }
      if (struct.isSetLocationIds()) {
        {
          oprot.writeI32(struct.locationIds.size());
          for (int _iter161 : struct.locationIds)
          {
            oprot.writeI32(_iter161);
          }
        }
      }
      if (struct.isSetLimitToLocations()) {
        oprot.writeBool(struct.limitToLocations);
      }
      if (struct.isSetLimitToAllowedUsers()) {
        oprot.writeBool(struct.limitToAllowedUsers);
      }
      if (struct.isSetHasUsbAccess()) {
        oprot.writeBool(struct.hasUsbAccess);
      }
      if (struct.isSetNetworkShares()) {
        {
          oprot.writeI32(struct.networkShares.size());
          for (NetShare _iter162 : struct.networkShares)
          {
            _iter162.write(oprot);
          }
        }
      }
    }

    @Override
    public void read(org.apache.thrift.protocol.TProtocol prot, LectureRead struct) throws org.apache.thrift.TException {
      TTupleProtocol iprot = (TTupleProtocol) prot;
      BitSet incoming = iprot.readBitSet(28);
      if (incoming.get(0)) {
        struct.lectureId = iprot.readString();
        struct.setLectureIdIsSet(true);
      }
      if (incoming.get(1)) {
        struct.lectureName = iprot.readString();
        struct.setLectureNameIsSet(true);
      }
      if (incoming.get(2)) {
        struct.description = iprot.readString();
        struct.setDescriptionIsSet(true);
      }
      if (incoming.get(3)) {
        struct.imageVersionId = iprot.readString();
        struct.setImageVersionIdIsSet(true);
      }
      if (incoming.get(4)) {
        struct.imageBaseId = iprot.readString();
        struct.setImageBaseIdIsSet(true);
      }
      if (incoming.get(5)) {
        struct.autoUpdate = iprot.readBool();
        struct.setAutoUpdateIsSet(true);
      }
      if (incoming.get(6)) {
        struct.isEnabled = iprot.readBool();
        struct.setIsEnabledIsSet(true);
      }
      if (incoming.get(7)) {
        struct.startTime = iprot.readI64();
        struct.setStartTimeIsSet(true);
      }
      if (incoming.get(8)) {
        struct.endTime = iprot.readI64();
        struct.setEndTimeIsSet(true);
      }
      if (incoming.get(9)) {
        struct.lastUsed = iprot.readI64();
        struct.setLastUsedIsSet(true);
      }
      if (incoming.get(10)) {
        struct.useCount = iprot.readI32();
        struct.setUseCountIsSet(true);
      }
      if (incoming.get(11)) {
        struct.createTime = iprot.readI64();
        struct.setCreateTimeIsSet(true);
      }
      if (incoming.get(12)) {
        struct.updateTime = iprot.readI64();
        struct.setUpdateTimeIsSet(true);
      }
      if (incoming.get(13)) {
        struct.ownerId = iprot.readString();
        struct.setOwnerIdIsSet(true);
      }
      if (incoming.get(14)) {
        struct.updaterId = iprot.readString();
        struct.setUpdaterIdIsSet(true);
      }
      if (incoming.get(15)) {
        struct.runscript = iprot.readString();
        struct.setRunscriptIsSet(true);
      }
      if (incoming.get(16)) {
        {
          org.apache.thrift.protocol.TList _list163 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
          struct.nics = new ArrayList<String>(_list163.size);
          String _elem164;
          for (int _i165 = 0; _i165 < _list163.size; ++_i165)
          {
            _elem164 = iprot.readString();
            struct.nics.add(_elem164);
          }
        }
        struct.setNicsIsSet(true);
      }
      if (incoming.get(17)) {
        {
          org.apache.thrift.protocol.TList _list166 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, iprot.readI32());
          struct.allowedUsers = new ArrayList<String>(_list166.size);
          String _elem167;
          for (int _i168 = 0; _i168 < _list166.size; ++_i168)
          {
            _elem167 = iprot.readString();
            struct.allowedUsers.add(_elem167);
          }
        }
        struct.setAllowedUsersIsSet(true);
      }
      if (incoming.get(18)) {
        {
          org.apache.thrift.protocol.TList _list169 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
          struct.networkExceptions = new ArrayList<NetRule>(_list169.size);
          NetRule _elem170;
          for (int _i171 = 0; _i171 < _list169.size; ++_i171)
          {
            _elem170 = new NetRule();
            _elem170.read(iprot);
            struct.networkExceptions.add(_elem170);
          }
        }
        struct.setNetworkExceptionsIsSet(true);
      }
      if (incoming.get(19)) {
        struct.isExam = iprot.readBool();
        struct.setIsExamIsSet(true);
      }
      if (incoming.get(20)) {
        struct.hasInternetAccess = iprot.readBool();
        struct.setHasInternetAccessIsSet(true);
      }
      if (incoming.get(21)) {
        struct.defaultPermissions = new LecturePermissions();
        struct.defaultPermissions.read(iprot);
        struct.setDefaultPermissionsIsSet(true);
      }
      if (incoming.get(22)) {
        struct.userPermissions = new LecturePermissions();
        struct.userPermissions.read(iprot);
        struct.setUserPermissionsIsSet(true);
      }
      if (incoming.get(23)) {
        {
          org.apache.thrift.protocol.TList _list172 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, iprot.readI32());
          struct.locationIds = new ArrayList<Integer>(_list172.size);
          int _elem173;
          for (int _i174 = 0; _i174 < _list172.size; ++_i174)
          {
            _elem173 = iprot.readI32();
            struct.locationIds.add(_elem173);
          }
        }
        struct.setLocationIdsIsSet(true);
      }
      if (incoming.get(24)) {
        struct.limitToLocations = iprot.readBool();
        struct.setLimitToLocationsIsSet(true);
      }
      if (incoming.get(25)) {
        struct.limitToAllowedUsers = iprot.readBool();
        struct.setLimitToAllowedUsersIsSet(true);
      }
      if (incoming.get(26)) {
        struct.hasUsbAccess = iprot.readBool();
        struct.setHasUsbAccessIsSet(true);
      }
      if (incoming.get(27)) {
        {
          org.apache.thrift.protocol.TList _list175 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, iprot.readI32());
          struct.networkShares = new ArrayList<NetShare>(_list175.size);
          NetShare _elem176;
          for (int _i177 = 0; _i177 < _list175.size; ++_i177)
          {
            _elem176 = new NetShare();
            _elem176.read(iprot);
            struct.networkShares.add(_elem176);
          }
        }
        struct.setNetworkSharesIsSet(true);
      }
    }
  }

}