package fr.ifremer.dali.dto.data.survey;
   
   import fr.ifremer.dali.dto.CoordinateDTO;
   import fr.ifremer.dali.dto.ErrorDTO;
   import fr.ifremer.dali.dto.SynchronizationStatusDTO;
   import fr.ifremer.dali.dto.configuration.programStrategy.PmfmStrategyDTO;
   import fr.ifremer.dali.dto.configuration.programStrategy.ProgramDTO;
   import fr.ifremer.dali.dto.data.measurement.MeasurementDTO;
   import fr.ifremer.dali.dto.data.photo.PhotoDTO;
  import fr.ifremer.dali.dto.data.sampling.SamplingOperationDTO;
  import fr.ifremer.dali.dto.referential.DepartmentDTO;
  import fr.ifremer.dali.dto.referential.LocationDTO;
  import fr.ifremer.dali.dto.referential.PersonDTO;
  import fr.ifremer.dali.dto.referential.PositioningSystemDTO;
  import fr.ifremer.dali.dto.referential.QualityLevelDTO;
  import fr.ifremer.dali.dto.referential.pmfm.PmfmDTO;
  import fr.ifremer.quadrige3.ui.core.dto.QuadrigeAbstractBean;
  import java.time.LocalDate;
  import java.util.Collection;
  import java.util.Date;
  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:02 CEST 2022")
  public abstract class AbstractSurveyDTOBean extends QuadrigeAbstractBean implements SurveyDTO {
  
      private static final long serialVersionUID = 3775768435904362296L;
  
      protected String name;
  
      protected LocalDate date;
  
      protected Integer time;
  
      protected Double bottomDepth;
  
      protected String comment;
  
      protected String positioningComment;
  
      protected Date controlDate;
  
      protected Date validationDate;
  
      protected String validationComment;
  
      protected Date qualificationDate;
  
      protected String qualificationComment;
  
      protected Date updateDate;
  
      protected boolean dirty;
  
      protected boolean samplingOperationsLoaded;
  
      protected boolean observersLoaded;
  
      protected boolean measurementsLoaded;
  
      protected boolean photosLoaded;
  
      protected DepartmentDTO department;
  
      protected CoordinateDTO coordinate;
  
      protected PositioningSystemDTO positioning;
  
      protected CampaignDTO campaign;
  
      protected OccasionDTO occasion;
  
      protected List<PmfmDTO> individualPmfms;
  
      protected List<PmfmDTO> pmfms;
  
      protected Collection<SamplingOperationDTO> samplingOperations;
  
      protected List<PhotoDTO> photos;
  
      protected ProgramDTO program;
  
      protected List<MeasurementDTO> measurements;
  
      protected Collection<PersonDTO> observers;
  
      protected SynchronizationStatusDTO synchronizationStatus;
  
      protected Collection<ErrorDTO> errors;
  
      protected List<MeasurementDTO> individualMeasurements;
  
      protected LocationDTO location;
  
      protected QualityLevelDTO qualityLevel;
  
      protected Collection<PmfmStrategyDTO> pmfmStrategies;
  
     @Override
     public String getName() {
         return name;
     }
 
     @Override
     public void setName(String name) {
         String oldValue = getName();
         this.name = name;
         firePropertyChange(PROPERTY_NAME, oldValue, name);
     }
 
     @Override
     public LocalDate getDate() {
         return date;
     }
 
     @Override
     public void setDate(LocalDate date) {
         LocalDate oldValue = getDate();
         this.date = date;
         firePropertyChange(PROPERTY_DATE, oldValue, date);
     }
 
     @Override
     public Integer getTime() {
         return time;
     }
 
     @Override
     public void setTime(Integer time) {
         Integer oldValue = getTime();
         this.time = time;
         firePropertyChange(PROPERTY_TIME, oldValue, time);
     }
 
     @Override
     public Double getBottomDepth() {
         return bottomDepth;
     }
 
     @Override
     public void setBottomDepth(Double bottomDepth) {
         Double oldValue = getBottomDepth();
         this.bottomDepth = bottomDepth;
         firePropertyChange(PROPERTY_BOTTOM_DEPTH, oldValue, bottomDepth);
     }
 
     @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 String getPositioningComment() {
         return positioningComment;
     }
 
     @Override
     public void setPositioningComment(String positioningComment) {
         String oldValue = getPositioningComment();
         this.positioningComment = positioningComment;
         firePropertyChange(PROPERTY_POSITIONING_COMMENT, oldValue, positioningComment);
     }
 
     @Override
     public Date getControlDate() {
         return controlDate;
     }
 
     @Override
     public void setControlDate(Date controlDate) {
         Date oldValue = getControlDate();
         this.controlDate = controlDate;
         firePropertyChange(PROPERTY_CONTROL_DATE, oldValue, controlDate);
     }
 
     @Override
     public Date getValidationDate() {
         return validationDate;
     }
 
     @Override
     public void setValidationDate(Date validationDate) {
         Date oldValue = getValidationDate();
         this.validationDate = validationDate;
         firePropertyChange(PROPERTY_VALIDATION_DATE, oldValue, validationDate);
     }
 
     @Override
     public String getValidationComment() {
         return validationComment;
     }
 
     @Override
     public void setValidationComment(String validationComment) {
         String oldValue = getValidationComment();
         this.validationComment = validationComment;
         firePropertyChange(PROPERTY_VALIDATION_COMMENT, oldValue, validationComment);
     }
 
     @Override
     public Date getQualificationDate() {
         return qualificationDate;
     }
 
     @Override
     public void setQualificationDate(Date qualificationDate) {
         Date oldValue = getQualificationDate();
         this.qualificationDate = qualificationDate;
         firePropertyChange(PROPERTY_QUALIFICATION_DATE, oldValue, qualificationDate);
     }
 
     @Override
     public String getQualificationComment() {
         return qualificationComment;
     }
 
     @Override
     public void setQualificationComment(String qualificationComment) {
         String oldValue = getQualificationComment();
         this.qualificationComment = qualificationComment;
         firePropertyChange(PROPERTY_QUALIFICATION_COMMENT, oldValue, qualificationComment);
     }
 
     @Override
     public Date getUpdateDate() {
         return updateDate;
     }
 
     @Override
     public void setUpdateDate(Date updateDate) {
         Date oldValue = getUpdateDate();
         this.updateDate = updateDate;
         firePropertyChange(PROPERTY_UPDATE_DATE, oldValue, updateDate);
     }
 
     @Override
     public boolean isDirty() {
         return dirty;
     }
 
     @Override
     public void setDirty(boolean dirty) {
         boolean oldValue = isDirty();
         this.dirty = dirty;
         firePropertyChange(PROPERTY_DIRTY, oldValue, dirty);
     }
 
     @Override
     public boolean isSamplingOperationsLoaded() {
         return samplingOperationsLoaded;
     }
 
     @Override
     public void setSamplingOperationsLoaded(boolean samplingOperationsLoaded) {
         boolean oldValue = isSamplingOperationsLoaded();
         this.samplingOperationsLoaded = samplingOperationsLoaded;
         firePropertyChange(PROPERTY_SAMPLING_OPERATIONS_LOADED, oldValue, samplingOperationsLoaded);
     }
 
     @Override
     public boolean isObserversLoaded() {
         return observersLoaded;
     }
 
     @Override
     public void setObserversLoaded(boolean observersLoaded) {
         boolean oldValue = isObserversLoaded();
         this.observersLoaded = observersLoaded;
         firePropertyChange(PROPERTY_OBSERVERS_LOADED, oldValue, observersLoaded);
     }
 
     @Override
     public boolean isMeasurementsLoaded() {
         return measurementsLoaded;
     }
 
     @Override
     public void setMeasurementsLoaded(boolean measurementsLoaded) {
         boolean oldValue = isMeasurementsLoaded();
         this.measurementsLoaded = measurementsLoaded;
         firePropertyChange(PROPERTY_MEASUREMENTS_LOADED, oldValue, measurementsLoaded);
     }
 
     @Override
     public boolean isPhotosLoaded() {
         return photosLoaded;
     }
 
     @Override
     public void setPhotosLoaded(boolean photosLoaded) {
         boolean oldValue = isPhotosLoaded();
         this.photosLoaded = photosLoaded;
         firePropertyChange(PROPERTY_PHOTOS_LOADED, oldValue, photosLoaded);
     }
 
     @Override
     public DepartmentDTO getDepartment() {
         return department;
     }
 
     @Override
     public void setDepartment(DepartmentDTO department) {
         DepartmentDTO oldValue = getDepartment();
         this.department = department;
         firePropertyChange(PROPERTY_DEPARTMENT, oldValue, department);
     }
 
     @Override
     public CoordinateDTO getCoordinate() {
         return coordinate;
     }
 
     @Override
     public void setCoordinate(CoordinateDTO coordinate) {
         CoordinateDTO oldValue = getCoordinate();
         this.coordinate = coordinate;
         firePropertyChange(PROPERTY_COORDINATE, oldValue, coordinate);
     }
 
     @Override
     public PositioningSystemDTO getPositioning() {
         return positioning;
     }
 
     @Override
     public void setPositioning(PositioningSystemDTO positioning) {
         PositioningSystemDTO oldValue = getPositioning();
         this.positioning = positioning;
         firePropertyChange(PROPERTY_POSITIONING, oldValue, positioning);
     }
 
     @Override
     public CampaignDTO getCampaign() {
         return campaign;
     }
 
     @Override
     public void setCampaign(CampaignDTO campaign) {
         CampaignDTO oldValue = getCampaign();
         this.campaign = campaign;
         firePropertyChange(PROPERTY_CAMPAIGN, oldValue, campaign);
     }
 
     @Override
     public OccasionDTO getOccasion() {
         return occasion;
     }
 
     @Override
     public void setOccasion(OccasionDTO occasion) {
         OccasionDTO oldValue = getOccasion();
         this.occasion = occasion;
         firePropertyChange(PROPERTY_OCCASION, oldValue, occasion);
     }
 
     @Override
     public PmfmDTO getIndividualPmfms(int index) {
         PmfmDTO o = getChild(individualPmfms, index);
         return o;
     }
 
     @Override
     public boolean isIndividualPmfmsEmpty() {
         return individualPmfms == null || individualPmfms.isEmpty();
     }
 
     @Override
     public int sizeIndividualPmfms() {
         return individualPmfms == null ? 0 : individualPmfms.size();
     }
 
     @Override
     public void addIndividualPmfms(PmfmDTO individualPmfms) {
         getIndividualPmfms().add(individualPmfms);
         firePropertyChange(PROPERTY_INDIVIDUAL_PMFMS, null, individualPmfms);
     }
 
     @Override
     public void addAllIndividualPmfms(Collection<PmfmDTO> individualPmfms) {
         getIndividualPmfms().addAll(individualPmfms);
         firePropertyChange(PROPERTY_INDIVIDUAL_PMFMS, null, individualPmfms);
     }
 
     @Override
     public boolean removeIndividualPmfms(PmfmDTO individualPmfms) {
         boolean removed = getIndividualPmfms().remove(individualPmfms);
         if (removed) {
             firePropertyChange(PROPERTY_INDIVIDUAL_PMFMS, individualPmfms, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllIndividualPmfms(Collection<PmfmDTO> individualPmfms) {
         boolean  removed = getIndividualPmfms().removeAll(individualPmfms);
         if (removed) {
             firePropertyChange(PROPERTY_INDIVIDUAL_PMFMS, individualPmfms, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsIndividualPmfms(PmfmDTO individualPmfms) {
         boolean contains = getIndividualPmfms().contains(individualPmfms);
         return contains;
     }
 
     @Override
     public boolean containsAllIndividualPmfms(Collection<PmfmDTO> individualPmfms) {
         boolean  contains = getIndividualPmfms().containsAll(individualPmfms);
         return contains;
     }
 
     @Override
     public List<PmfmDTO> getIndividualPmfms() {
     if (individualPmfms == null) {
         individualPmfms = new LinkedList<PmfmDTO>();
     }
     return individualPmfms;
 }
 
     @Override
     public void setIndividualPmfms(List<PmfmDTO> individualPmfms) {
         List<PmfmDTO> oldValue = getIndividualPmfms();
         this.individualPmfms = individualPmfms;
         firePropertyChange(PROPERTY_INDIVIDUAL_PMFMS, oldValue, individualPmfms);
     }
 
     @Override
     public PmfmDTO getPmfms(int index) {
         PmfmDTO o = getChild(pmfms, index);
         return o;
     }
 
     @Override
     public boolean isPmfmsEmpty() {
         return pmfms == null || pmfms.isEmpty();
     }
 
     @Override
     public int sizePmfms() {
         return pmfms == null ? 0 : pmfms.size();
     }
 
     @Override
     public void addPmfms(PmfmDTO pmfms) {
         getPmfms().add(pmfms);
         firePropertyChange(PROPERTY_PMFMS, null, pmfms);
     }
 
     @Override
     public void addAllPmfms(Collection<PmfmDTO> pmfms) {
         getPmfms().addAll(pmfms);
         firePropertyChange(PROPERTY_PMFMS, null, pmfms);
     }
 
     @Override
     public boolean removePmfms(PmfmDTO pmfms) {
         boolean removed = getPmfms().remove(pmfms);
         if (removed) {
             firePropertyChange(PROPERTY_PMFMS, pmfms, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllPmfms(Collection<PmfmDTO> pmfms) {
         boolean  removed = getPmfms().removeAll(pmfms);
         if (removed) {
             firePropertyChange(PROPERTY_PMFMS, pmfms, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsPmfms(PmfmDTO pmfms) {
         boolean contains = getPmfms().contains(pmfms);
         return contains;
     }
 
     @Override
     public boolean containsAllPmfms(Collection<PmfmDTO> pmfms) {
         boolean  contains = getPmfms().containsAll(pmfms);
         return contains;
     }
 
     @Override
     public List<PmfmDTO> getPmfms() {
     if (pmfms == null) {
         pmfms = new LinkedList<PmfmDTO>();
     }
     return pmfms;
 }
 
     @Override
     public void setPmfms(List<PmfmDTO> pmfms) {
         List<PmfmDTO> oldValue = getPmfms();
         this.pmfms = pmfms;
         firePropertyChange(PROPERTY_PMFMS, oldValue, pmfms);
     }
 
     @Override
     public SamplingOperationDTO getSamplingOperations(int index) {
         SamplingOperationDTO o = getChild(samplingOperations, index);
         return o;
     }
 
     @Override
     public boolean isSamplingOperationsEmpty() {
         return samplingOperations == null || samplingOperations.isEmpty();
     }
 
     @Override
     public int sizeSamplingOperations() {
         return samplingOperations == null ? 0 : samplingOperations.size();
     }
 
     @Override
     public void addSamplingOperations(SamplingOperationDTO samplingOperations) {
         getSamplingOperations().add(samplingOperations);
         firePropertyChange(PROPERTY_SAMPLING_OPERATIONS, null, samplingOperations);
     }
 
     @Override
     public void addAllSamplingOperations(Collection<SamplingOperationDTO> samplingOperations) {
         getSamplingOperations().addAll(samplingOperations);
         firePropertyChange(PROPERTY_SAMPLING_OPERATIONS, null, samplingOperations);
     }
 
     @Override
     public boolean removeSamplingOperations(SamplingOperationDTO samplingOperations) {
         boolean removed = getSamplingOperations().remove(samplingOperations);
         if (removed) {
             firePropertyChange(PROPERTY_SAMPLING_OPERATIONS, samplingOperations, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllSamplingOperations(Collection<SamplingOperationDTO> samplingOperations) {
         boolean  removed = getSamplingOperations().removeAll(samplingOperations);
         if (removed) {
             firePropertyChange(PROPERTY_SAMPLING_OPERATIONS, samplingOperations, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsSamplingOperations(SamplingOperationDTO samplingOperations) {
         boolean contains = getSamplingOperations().contains(samplingOperations);
         return contains;
     }
 
     @Override
     public boolean containsAllSamplingOperations(Collection<SamplingOperationDTO> samplingOperations) {
         boolean  contains = getSamplingOperations().containsAll(samplingOperations);
         return contains;
     }
 
     @Override
     public Collection<SamplingOperationDTO> getSamplingOperations() {
     if (samplingOperations == null) {
         samplingOperations = new LinkedList<SamplingOperationDTO>();
     }
     return samplingOperations;
 }
 
     @Override
     public void setSamplingOperations(Collection<SamplingOperationDTO> samplingOperations) {
         Collection<SamplingOperationDTO> oldValue = getSamplingOperations();
         this.samplingOperations = samplingOperations;
         firePropertyChange(PROPERTY_SAMPLING_OPERATIONS, oldValue, samplingOperations);
     }
 
     @Override
     public PhotoDTO getPhotos(int index) {
         PhotoDTO o = getChild(photos, index);
         return o;
     }
 
     @Override
     public boolean isPhotosEmpty() {
         return photos == null || photos.isEmpty();
     }
 
     @Override
     public int sizePhotos() {
         return photos == null ? 0 : photos.size();
     }
 
     @Override
     public void addPhotos(PhotoDTO photos) {
         getPhotos().add(photos);
         firePropertyChange(PROPERTY_PHOTOS, null, photos);
     }
 
     @Override
     public void addAllPhotos(Collection<PhotoDTO> photos) {
         getPhotos().addAll(photos);
         firePropertyChange(PROPERTY_PHOTOS, null, photos);
     }
 
     @Override
     public boolean removePhotos(PhotoDTO photos) {
         boolean removed = getPhotos().remove(photos);
         if (removed) {
             firePropertyChange(PROPERTY_PHOTOS, photos, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllPhotos(Collection<PhotoDTO> photos) {
         boolean  removed = getPhotos().removeAll(photos);
         if (removed) {
             firePropertyChange(PROPERTY_PHOTOS, photos, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsPhotos(PhotoDTO photos) {
         boolean contains = getPhotos().contains(photos);
         return contains;
     }
 
     @Override
     public boolean containsAllPhotos(Collection<PhotoDTO> photos) {
         boolean  contains = getPhotos().containsAll(photos);
         return contains;
     }
 
     @Override
     public List<PhotoDTO> getPhotos() {
     if (photos == null) {
         photos = new LinkedList<PhotoDTO>();
     }
     return photos;
 }
 
     @Override
     public void setPhotos(List<PhotoDTO> photos) {
         List<PhotoDTO> oldValue = getPhotos();
         this.photos = photos;
         firePropertyChange(PROPERTY_PHOTOS, oldValue, photos);
     }
 
     @Override
     public ProgramDTO getProgram() {
         return program;
     }
 
     @Override
     public void setProgram(ProgramDTO program) {
         ProgramDTO oldValue = getProgram();
         this.program = program;
         firePropertyChange(PROPERTY_PROGRAM, oldValue, program);
     }
 
     @Override
     public MeasurementDTO getMeasurements(int index) {
         MeasurementDTO o = getChild(measurements, index);
         return o;
     }
 
     @Override
     public boolean isMeasurementsEmpty() {
         return measurements == null || measurements.isEmpty();
     }
 
     @Override
     public int sizeMeasurements() {
         return measurements == null ? 0 : measurements.size();
     }
 
     @Override
     public void addMeasurements(MeasurementDTO measurements) {
         getMeasurements().add(measurements);
         firePropertyChange(PROPERTY_MEASUREMENTS, null, measurements);
     }
 
     @Override
     public void addAllMeasurements(Collection<MeasurementDTO> measurements) {
         getMeasurements().addAll(measurements);
         firePropertyChange(PROPERTY_MEASUREMENTS, null, measurements);
     }
 
     @Override
     public boolean removeMeasurements(MeasurementDTO measurements) {
         boolean removed = getMeasurements().remove(measurements);
         if (removed) {
             firePropertyChange(PROPERTY_MEASUREMENTS, measurements, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllMeasurements(Collection<MeasurementDTO> measurements) {
         boolean  removed = getMeasurements().removeAll(measurements);
         if (removed) {
             firePropertyChange(PROPERTY_MEASUREMENTS, measurements, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsMeasurements(MeasurementDTO measurements) {
         boolean contains = getMeasurements().contains(measurements);
         return contains;
     }
 
     @Override
     public boolean containsAllMeasurements(Collection<MeasurementDTO> measurements) {
         boolean  contains = getMeasurements().containsAll(measurements);
         return contains;
     }
 
     @Override
     public List<MeasurementDTO> getMeasurements() {
     if (measurements == null) {
         measurements = new LinkedList<MeasurementDTO>();
     }
     return measurements;
 }
 
     @Override
     public void setMeasurements(List<MeasurementDTO> measurements) {
         List<MeasurementDTO> oldValue = getMeasurements();
         this.measurements = measurements;
         firePropertyChange(PROPERTY_MEASUREMENTS, oldValue, measurements);
     }
 
     @Override
     public PersonDTO getObservers(int index) {
         PersonDTO o = getChild(observers, index);
         return o;
     }
 
     @Override
     public boolean isObserversEmpty() {
         return observers == null || observers.isEmpty();
     }
 
     @Override
     public int sizeObservers() {
         return observers == null ? 0 : observers.size();
     }
 
     @Override
     public void addObservers(PersonDTO observers) {
         getObservers().add(observers);
         firePropertyChange(PROPERTY_OBSERVERS, null, observers);
     }
 
     @Override
     public void addAllObservers(Collection<PersonDTO> observers) {
         getObservers().addAll(observers);
         firePropertyChange(PROPERTY_OBSERVERS, null, observers);
     }
 
     @Override
     public boolean removeObservers(PersonDTO observers) {
         boolean removed = getObservers().remove(observers);
         if (removed) {
             firePropertyChange(PROPERTY_OBSERVERS, observers, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllObservers(Collection<PersonDTO> observers) {
         boolean  removed = getObservers().removeAll(observers);
         if (removed) {
             firePropertyChange(PROPERTY_OBSERVERS, observers, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsObservers(PersonDTO observers) {
         boolean contains = getObservers().contains(observers);
         return contains;
     }
 
     @Override
     public boolean containsAllObservers(Collection<PersonDTO> observers) {
         boolean  contains = getObservers().containsAll(observers);
         return contains;
     }
 
     @Override
     public Collection<PersonDTO> getObservers() {
     if (observers == null) {
         observers = new LinkedList<PersonDTO>();
     }
     return observers;
 }
 
     @Override
     public void setObservers(Collection<PersonDTO> observers) {
         Collection<PersonDTO> oldValue = getObservers();
         this.observers = observers;
         firePropertyChange(PROPERTY_OBSERVERS, oldValue, observers);
     }
 
     @Override
     public SynchronizationStatusDTO getSynchronizationStatus() {
         return synchronizationStatus;
     }
 
     @Override
     public void setSynchronizationStatus(SynchronizationStatusDTO synchronizationStatus) {
         SynchronizationStatusDTO oldValue = getSynchronizationStatus();
         this.synchronizationStatus = synchronizationStatus;
         firePropertyChange(PROPERTY_SYNCHRONIZATION_STATUS, oldValue, synchronizationStatus);
     }
 
     @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 MeasurementDTO getIndividualMeasurements(int index) {
         MeasurementDTO o = getChild(individualMeasurements, index);
         return o;
     }
 
     @Override
     public boolean isIndividualMeasurementsEmpty() {
         return individualMeasurements == null || individualMeasurements.isEmpty();
     }
 
     @Override
     public int sizeIndividualMeasurements() {
         return individualMeasurements == null ? 0 : individualMeasurements.size();
     }
 
     @Override
     public void addIndividualMeasurements(MeasurementDTO individualMeasurements) {
         getIndividualMeasurements().add(individualMeasurements);
         firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS, null, individualMeasurements);
     }
 
     @Override
     public void addAllIndividualMeasurements(Collection<MeasurementDTO> individualMeasurements) {
         getIndividualMeasurements().addAll(individualMeasurements);
         firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS, null, individualMeasurements);
     }
 
     @Override
     public boolean removeIndividualMeasurements(MeasurementDTO individualMeasurements) {
         boolean removed = getIndividualMeasurements().remove(individualMeasurements);
         if (removed) {
             firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS, individualMeasurements, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllIndividualMeasurements(Collection<MeasurementDTO> individualMeasurements) {
         boolean  removed = getIndividualMeasurements().removeAll(individualMeasurements);
         if (removed) {
             firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS, individualMeasurements, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsIndividualMeasurements(MeasurementDTO individualMeasurements) {
         boolean contains = getIndividualMeasurements().contains(individualMeasurements);
         return contains;
     }
 
     @Override
     public boolean containsAllIndividualMeasurements(Collection<MeasurementDTO> individualMeasurements) {
         boolean  contains = getIndividualMeasurements().containsAll(individualMeasurements);
         return contains;
     }
 
     @Override
     public List<MeasurementDTO> getIndividualMeasurements() {
     if (individualMeasurements == null) {
         individualMeasurements = new LinkedList<MeasurementDTO>();
     }
     return individualMeasurements;
 }
 
     @Override
     public void setIndividualMeasurements(List<MeasurementDTO> individualMeasurements) {
         List<MeasurementDTO> oldValue = getIndividualMeasurements();
         this.individualMeasurements = individualMeasurements;
         firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS, oldValue, individualMeasurements);
     }
 
     @Override
     public LocationDTO getLocation() {
         return location;
     }
 
     @Override
     public void setLocation(LocationDTO location) {
         LocationDTO oldValue = getLocation();
         this.location = location;
         firePropertyChange(PROPERTY_LOCATION, oldValue, location);
     }
 
     @Override
     public QualityLevelDTO getQualityLevel() {
         return qualityLevel;
     }
 
     @Override
     public void setQualityLevel(QualityLevelDTO qualityLevel) {
         QualityLevelDTO oldValue = getQualityLevel();
         this.qualityLevel = qualityLevel;
         firePropertyChange(PROPERTY_QUALITY_LEVEL, oldValue, qualityLevel);
     }
 
     @Override
     public PmfmStrategyDTO getPmfmStrategies(int index) {
         PmfmStrategyDTO o = getChild(pmfmStrategies, index);
         return o;
     }
 
     @Override
     public boolean isPmfmStrategiesEmpty() {
         return pmfmStrategies == null || pmfmStrategies.isEmpty();
     }
 
     @Override
     public int sizePmfmStrategies() {
         return pmfmStrategies == null ? 0 : pmfmStrategies.size();
     }
 
     @Override
     public void addPmfmStrategies(PmfmStrategyDTO pmfmStrategies) {
         getPmfmStrategies().add(pmfmStrategies);
         firePropertyChange(PROPERTY_PMFM_STRATEGIES, null, pmfmStrategies);
     }
 
     @Override
     public void addAllPmfmStrategies(Collection<PmfmStrategyDTO> pmfmStrategies) {
         getPmfmStrategies().addAll(pmfmStrategies);
         firePropertyChange(PROPERTY_PMFM_STRATEGIES, null, pmfmStrategies);
     }
 
     @Override
     public boolean removePmfmStrategies(PmfmStrategyDTO pmfmStrategies) {
         boolean removed = getPmfmStrategies().remove(pmfmStrategies);
         if (removed) {
             firePropertyChange(PROPERTY_PMFM_STRATEGIES, pmfmStrategies, null);
         }
         return removed;
     }
 
     @Override
     public boolean removeAllPmfmStrategies(Collection<PmfmStrategyDTO> pmfmStrategies) {
         boolean  removed = getPmfmStrategies().removeAll(pmfmStrategies);
         if (removed) {
             firePropertyChange(PROPERTY_PMFM_STRATEGIES, pmfmStrategies, null);
         }
         return removed;
     }
 
     @Override
     public boolean containsPmfmStrategies(PmfmStrategyDTO pmfmStrategies) {
         boolean contains = getPmfmStrategies().contains(pmfmStrategies);
         return contains;
     }
 
     @Override
     public boolean containsAllPmfmStrategies(Collection<PmfmStrategyDTO> pmfmStrategies) {
         boolean  contains = getPmfmStrategies().containsAll(pmfmStrategies);
         return contains;
     }
 
     @Override
     public Collection<PmfmStrategyDTO> getPmfmStrategies() {
     if (pmfmStrategies == null) {
         pmfmStrategies = new LinkedList<PmfmStrategyDTO>();
     }
     return pmfmStrategies;
 }
 
     @Override
     public void setPmfmStrategies(Collection<PmfmStrategyDTO> pmfmStrategies) {
         Collection<PmfmStrategyDTO> oldValue = getPmfmStrategies();
         this.pmfmStrategies = pmfmStrategies;
         firePropertyChange(PROPERTY_PMFM_STRATEGIES, oldValue, pmfmStrategies);
     }
 
 } //AbstractSurveyDTOBean