package fr.ifremer.dali.dto.configuration.programStrategy;
   
   import fr.ifremer.dali.dto.ErrorDTO;
   import fr.ifremer.dali.dto.referential.DepartmentDTO;
   import fr.ifremer.dali.dto.referential.LocationDTO;
   import fr.ifremer.dali.dto.referential.PersonDTO;
   import fr.ifremer.quadrige3.ui.core.dto.referential.BaseReferentialDTOBean;
   import java.util.Collection;
   import java.util.LinkedList;
  import java.util.List;
  import javax.annotation.Generated;
  
  @Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Mon May 09 09:01:03 CEST 2022")
  public abstract class AbstractProgramDTOBean extends BaseReferentialDTOBean implements ProgramDTO {
  
      private static final long serialVersionUID = 7293639208041986101L;
  
      protected String code;
  
      protected String description;
  
      protected String comment;
  
      protected boolean strategiesLoaded;
  
      protected boolean locationsLoaded;
  
      protected boolean newCode;
  
      protected boolean departmentHermetic;
  
      protected Collection<StrategyDTO> strategies;
  
      protected List<LocationDTO> locations;
  
      protected Collection<ErrorDTO> errors;
  
      protected Collection<PersonDTO> managerPersons;
  
      protected Collection<PersonDTO> recorderPersons;
  
      protected Collection<DepartmentDTO> recorderDepartments;
  
      @Override
      public String getCode() {
          return code;
      }
  
      @Override
      public void setCode(String code) {
          String oldValue = getCode();
          this.code = code;
          firePropertyChange(PROPERTY_CODE, oldValue, code);
      }
  
      @Override
      public String getDescription() {
          return description;
      }
  
      @Override
      public void setDescription(String description) {
          String oldValue = getDescription();
          this.description = description;
          firePropertyChange(PROPERTY_DESCRIPTION, oldValue, description);
      }
  
      @Override
      public String getComment() {
          return comment;
      }
  
      @Override
      public void setComment(String comment) {
          String oldValue = getComment();
          this.comment = comment;
          firePropertyChange(PROPERTY_COMMENT, oldValue, comment);
      }
  
      @Override
      public boolean isStrategiesLoaded() {
          return strategiesLoaded;
      }
  
      @Override
      public void setStrategiesLoaded(boolean strategiesLoaded) {
          boolean oldValue = isStrategiesLoaded();
          this.strategiesLoaded = strategiesLoaded;
          firePropertyChange(PROPERTY_STRATEGIES_LOADED, oldValue, strategiesLoaded);
      }
  
      @Override
      public boolean isLocationsLoaded() {
          return locationsLoaded;
      }
  
      @Override
      public void setLocationsLoaded(boolean locationsLoaded) {
          boolean oldValue = isLocationsLoaded();
         this.locationsLoaded = locationsLoaded;
         firePropertyChange(PROPERTY_LOCATIONS_LOADED, oldValue, locationsLoaded);
     }
 
     @Override
     public boolean isNewCode() {
         return newCode;
     }
 
     @Override
     public void setNewCode(boolean newCode) {
         boolean oldValue = isNewCode();
         this.newCode = newCode;
         firePropertyChange(PROPERTY_NEW_CODE, oldValue, newCode);
     }
 
     @Override
     public boolean isDepartmentHermetic() {
         return departmentHermetic;
     }
 
     @Override
     public void setDepartmentHermetic(boolean departmentHermetic) {
         boolean oldValue = isDepartmentHermetic();
         this.departmentHermetic = departmentHermetic;
         firePropertyChange(PROPERTY_DEPARTMENT_HERMETIC, oldValue, departmentHermetic);
     }
 
     @Override
     public StrategyDTO getStrategies(int index) {
         StrategyDTO o = getChild(strategies, index);
         return o;
     }
 
     @Override
     public boolean isStrategiesEmpty() {
         return strategies == null || strategies.isEmpty();
     }
 
     @Override
     public int sizeStrategies() {
         return strategies == null ? 0 : strategies.size();
     }
 
     @Override
     public void addStrategies(StrategyDTO strategies) {
         getStrategies().add(strategies);
         firePropertyChange(PROPERTY_STRATEGIES, null, strategies);
     }
 
     @Override
     public void addAllStrategies(Collection<StrategyDTO> strategies) {
         getStrategies().addAll(strategies);
         firePropertyChange(PROPERTY_STRATEGIES, null, strategies);
     }
 
     @Override
     public boolean removeStrategies(StrategyDTO strategies) {
         boolean removed = getStrategies().remove(strategies);
         if (removed) {
             firePropertyChange(PROPERTY_STRATEGIES, strategies, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllStrategies(Collection<StrategyDTO> strategies) {
         boolean  removed = getStrategies().removeAll(strategies);
         if (removed) {
             firePropertyChange(PROPERTY_STRATEGIES, strategies, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsStrategies(StrategyDTO strategies) {
         boolean contains = getStrategies().contains(strategies);
         return contains;
     }
 
     @Override
     public boolean containsAllStrategies(Collection<StrategyDTO> strategies) {
         boolean  contains = getStrategies().containsAll(strategies);
         return contains;
     }
 
     @Override
     public Collection<StrategyDTO> getStrategies() {
     if (strategies == null) {
         strategies = new LinkedList<StrategyDTO>();
     }
     return strategies;
 }
 
     @Override
     public void setStrategies(Collection<StrategyDTO> strategies) {
         Collection<StrategyDTO> oldValue = getStrategies();
         this.strategies = strategies;
         firePropertyChange(PROPERTY_STRATEGIES, oldValue, strategies);
     }
 
     @Override
     public LocationDTO getLocations(int index) {
         LocationDTO o = getChild(locations, index);
         return o;
     }
 
     @Override
     public boolean isLocationsEmpty() {
         return locations == null || locations.isEmpty();
     }
 
     @Override
     public int sizeLocations() {
         return locations == null ? 0 : locations.size();
     }
 
     @Override
     public void addLocations(LocationDTO locations) {
         getLocations().add(locations);
         firePropertyChange(PROPERTY_LOCATIONS, null, locations);
     }
 
     @Override
     public void addAllLocations(Collection<LocationDTO> locations) {
         getLocations().addAll(locations);
         firePropertyChange(PROPERTY_LOCATIONS, null, locations);
     }
 
     @Override
     public boolean removeLocations(LocationDTO locations) {
         boolean removed = getLocations().remove(locations);
         if (removed) {
             firePropertyChange(PROPERTY_LOCATIONS, locations, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllLocations(Collection<LocationDTO> locations) {
         boolean  removed = getLocations().removeAll(locations);
         if (removed) {
             firePropertyChange(PROPERTY_LOCATIONS, locations, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsLocations(LocationDTO locations) {
         boolean contains = getLocations().contains(locations);
         return contains;
     }
 
     @Override
     public boolean containsAllLocations(Collection<LocationDTO> locations) {
         boolean  contains = getLocations().containsAll(locations);
         return contains;
     }
 
     @Override
     public List<LocationDTO> getLocations() {
     if (locations == null) {
         locations = new LinkedList<LocationDTO>();
     }
     return locations;
 }
 
     @Override
     public void setLocations(List<LocationDTO> locations) {
         List<LocationDTO> oldValue = getLocations();
         this.locations = locations;
         firePropertyChange(PROPERTY_LOCATIONS, oldValue, locations);
     }
 
     @Override
     public ErrorDTO getErrors(int index) {
         ErrorDTO o = getChild(errors, index);
         return o;
     }
 
     @Override
     public boolean isErrorsEmpty() {
         return errors == null || errors.isEmpty();
     }
 
     @Override
     public int sizeErrors() {
         return errors == null ? 0 : errors.size();
     }
 
     @Override
     public void addErrors(ErrorDTO errors) {
         getErrors().add(errors);
         firePropertyChange(PROPERTY_ERRORS, null, errors);
     }
 
     @Override
     public void addAllErrors(Collection<ErrorDTO> errors) {
         getErrors().addAll(errors);
         firePropertyChange(PROPERTY_ERRORS, null, errors);
     }
 
     @Override
     public boolean removeErrors(ErrorDTO errors) {
         boolean removed = getErrors().remove(errors);
         if (removed) {
             firePropertyChange(PROPERTY_ERRORS, errors, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllErrors(Collection<ErrorDTO> errors) {
         boolean  removed = getErrors().removeAll(errors);
         if (removed) {
             firePropertyChange(PROPERTY_ERRORS, errors, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsErrors(ErrorDTO errors) {
         boolean contains = getErrors().contains(errors);
         return contains;
     }
 
     @Override
     public boolean containsAllErrors(Collection<ErrorDTO> errors) {
         boolean  contains = getErrors().containsAll(errors);
         return contains;
     }
 
     @Override
     public Collection<ErrorDTO> getErrors() {
     if (errors == null) {
         errors = new LinkedList<ErrorDTO>();
     }
     return errors;
 }
 
     @Override
     public void setErrors(Collection<ErrorDTO> errors) {
         Collection<ErrorDTO> oldValue = getErrors();
         this.errors = errors;
         firePropertyChange(PROPERTY_ERRORS, oldValue, errors);
     }
 
     @Override
     public PersonDTO getManagerPersons(int index) {
         PersonDTO o = getChild(managerPersons, index);
         return o;
     }
 
     @Override
     public boolean isManagerPersonsEmpty() {
         return managerPersons == null || managerPersons.isEmpty();
     }
 
     @Override
     public int sizeManagerPersons() {
         return managerPersons == null ? 0 : managerPersons.size();
     }
 
     @Override
     public void addManagerPersons(PersonDTO managerPersons) {
         getManagerPersons().add(managerPersons);
         firePropertyChange(PROPERTY_MANAGER_PERSONS, null, managerPersons);
     }
 
     @Override
     public void addAllManagerPersons(Collection<PersonDTO> managerPersons) {
         getManagerPersons().addAll(managerPersons);
         firePropertyChange(PROPERTY_MANAGER_PERSONS, null, managerPersons);
     }
 
     @Override
     public boolean removeManagerPersons(PersonDTO managerPersons) {
         boolean removed = getManagerPersons().remove(managerPersons);
         if (removed) {
             firePropertyChange(PROPERTY_MANAGER_PERSONS, managerPersons, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllManagerPersons(Collection<PersonDTO> managerPersons) {
         boolean  removed = getManagerPersons().removeAll(managerPersons);
         if (removed) {
             firePropertyChange(PROPERTY_MANAGER_PERSONS, managerPersons, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsManagerPersons(PersonDTO managerPersons) {
         boolean contains = getManagerPersons().contains(managerPersons);
         return contains;
     }
 
     @Override
     public boolean containsAllManagerPersons(Collection<PersonDTO> managerPersons) {
         boolean  contains = getManagerPersons().containsAll(managerPersons);
         return contains;
     }
 
     @Override
     public Collection<PersonDTO> getManagerPersons() {
     if (managerPersons == null) {
         managerPersons = new LinkedList<PersonDTO>();
     }
     return managerPersons;
 }
 
     @Override
     public void setManagerPersons(Collection<PersonDTO> managerPersons) {
         Collection<PersonDTO> oldValue = getManagerPersons();
         this.managerPersons = managerPersons;
         firePropertyChange(PROPERTY_MANAGER_PERSONS, oldValue, managerPersons);
     }
 
     @Override
     public PersonDTO getRecorderPersons(int index) {
         PersonDTO o = getChild(recorderPersons, index);
         return o;
     }
 
     @Override
     public boolean isRecorderPersonsEmpty() {
         return recorderPersons == null || recorderPersons.isEmpty();
     }
 
     @Override
     public int sizeRecorderPersons() {
         return recorderPersons == null ? 0 : recorderPersons.size();
     }
 
     @Override
     public void addRecorderPersons(PersonDTO recorderPersons) {
         getRecorderPersons().add(recorderPersons);
         firePropertyChange(PROPERTY_RECORDER_PERSONS, null, recorderPersons);
     }
 
     @Override
     public void addAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         getRecorderPersons().addAll(recorderPersons);
         firePropertyChange(PROPERTY_RECORDER_PERSONS, null, recorderPersons);
     }
 
     @Override
     public boolean removeRecorderPersons(PersonDTO recorderPersons) {
         boolean removed = getRecorderPersons().remove(recorderPersons);
         if (removed) {
             firePropertyChange(PROPERTY_RECORDER_PERSONS, recorderPersons, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         boolean  removed = getRecorderPersons().removeAll(recorderPersons);
         if (removed) {
             firePropertyChange(PROPERTY_RECORDER_PERSONS, recorderPersons, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsRecorderPersons(PersonDTO recorderPersons) {
         boolean contains = getRecorderPersons().contains(recorderPersons);
         return contains;
     }
 
     @Override
     public boolean containsAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
         boolean  contains = getRecorderPersons().containsAll(recorderPersons);
         return contains;
     }
 
     @Override
     public Collection<PersonDTO> getRecorderPersons() {
     if (recorderPersons == null) {
         recorderPersons = new LinkedList<PersonDTO>();
     }
     return recorderPersons;
 }
 
     @Override
     public void setRecorderPersons(Collection<PersonDTO> recorderPersons) {
         Collection<PersonDTO> oldValue = getRecorderPersons();
         this.recorderPersons = recorderPersons;
         firePropertyChange(PROPERTY_RECORDER_PERSONS, oldValue, recorderPersons);
     }
 
     @Override
     public DepartmentDTO getRecorderDepartments(int index) {
         DepartmentDTO o = getChild(recorderDepartments, index);
         return o;
     }
 
     @Override
     public boolean isRecorderDepartmentsEmpty() {
         return recorderDepartments == null || recorderDepartments.isEmpty();
     }
 
     @Override
     public int sizeRecorderDepartments() {
         return recorderDepartments == null ? 0 : recorderDepartments.size();
     }
 
     @Override
     public void addRecorderDepartments(DepartmentDTO recorderDepartments) {
         getRecorderDepartments().add(recorderDepartments);
         firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, null, recorderDepartments);
     }
 
     @Override
     public void addAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         getRecorderDepartments().addAll(recorderDepartments);
         firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, null, recorderDepartments);
     }
 
     @Override
     public boolean removeRecorderDepartments(DepartmentDTO recorderDepartments) {
         boolean removed = getRecorderDepartments().remove(recorderDepartments);
         if (removed) {
             firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, recorderDepartments, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         boolean  removed = getRecorderDepartments().removeAll(recorderDepartments);
         if (removed) {
             firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, recorderDepartments, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsRecorderDepartments(DepartmentDTO recorderDepartments) {
         boolean contains = getRecorderDepartments().contains(recorderDepartments);
         return contains;
     }
 
     @Override
     public boolean containsAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         boolean  contains = getRecorderDepartments().containsAll(recorderDepartments);
         return contains;
     }
 
     @Override
     public Collection<DepartmentDTO> getRecorderDepartments() {
     if (recorderDepartments == null) {
         recorderDepartments = new LinkedList<DepartmentDTO>();
     }
     return recorderDepartments;
 }
 
     @Override
     public void setRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
         Collection<DepartmentDTO> oldValue = getRecorderDepartments();
         this.recorderDepartments = recorderDepartments;
         firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, oldValue, recorderDepartments);
     }
 
 } //AbstractProgramDTOBean