package fr.ifremer.dali.dto.data.sampling;
   
   import fr.ifremer.dali.dto.CoordinateDTO;
   import fr.ifremer.dali.dto.ErrorDTO;
   import fr.ifremer.dali.dto.data.measurement.MeasurementDTO;
   import fr.ifremer.dali.dto.referential.DepartmentDTO;
   import fr.ifremer.dali.dto.referential.LevelDTO;
   import fr.ifremer.dali.dto.referential.PositioningSystemDTO;
   import fr.ifremer.dali.dto.referential.SamplingEquipmentDTO;
  import fr.ifremer.dali.dto.referential.UnitDTO;
  import fr.ifremer.dali.dto.referential.pmfm.PmfmDTO;
  import fr.ifremer.quadrige3.ui.core.dto.QuadrigeAbstractBean;
  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 AbstractSamplingOperationDTOBean extends QuadrigeAbstractBean implements SamplingOperationDTO {
  
      private static final long serialVersionUID = 3977632187336962915L;
  
      protected String name;
  
      protected String comment;
  
      protected Integer time;
  
      protected Double size;
  
      protected UnitDTO sizeUnit;
  
      protected Double depth;
  
      protected Double minDepth;
  
      protected Double maxDepth;
  
      protected Integer individualCount;
  
      protected Date controlDate;
  
      protected boolean dirty;
  
      protected boolean measurementsLoaded;
  
      protected boolean individualMeasurementsLoaded;
  
      protected SamplingEquipmentDTO samplingEquipment;
  
      protected PositioningSystemDTO positioning;
  
      protected CoordinateDTO coordinate;
  
      protected LevelDTO depthLevel;
  
      protected DepartmentDTO samplingDepartment;
  
      protected List<PmfmDTO> pmfms;
  
      protected List<PmfmDTO> individualPmfms;
  
      protected List<MeasurementDTO> measurements;
  
      protected List<MeasurementDTO> individualMeasurements;
  
      protected Collection<ErrorDTO> errors;
  
      @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 String getComment() {
          return comment;
      }
  
      @Override
      public void setComment(String comment) {
          String oldValue = getComment();
          this.comment = comment;
          firePropertyChange(PROPERTY_COMMENT, oldValue, comment);
      }
  
      @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 getSize() {
         return size;
     }
 
     @Override
     public void setSize(Double size) {
         Double oldValue = getSize();
         this.size = size;
         firePropertyChange(PROPERTY_SIZE, oldValue, size);
     }
 
     @Override
     public UnitDTO getSizeUnit() {
         return sizeUnit;
     }
 
     @Override
     public void setSizeUnit(UnitDTO sizeUnit) {
         UnitDTO oldValue = getSizeUnit();
         this.sizeUnit = sizeUnit;
         firePropertyChange(PROPERTY_SIZE_UNIT, oldValue, sizeUnit);
     }
 
     @Override
     public Double getDepth() {
         return depth;
     }
 
     @Override
     public void setDepth(Double depth) {
         Double oldValue = getDepth();
         this.depth = depth;
         firePropertyChange(PROPERTY_DEPTH, oldValue, depth);
     }
 
     @Override
     public Double getMinDepth() {
         return minDepth;
     }
 
     @Override
     public void setMinDepth(Double minDepth) {
         Double oldValue = getMinDepth();
         this.minDepth = minDepth;
         firePropertyChange(PROPERTY_MIN_DEPTH, oldValue, minDepth);
     }
 
     @Override
     public Double getMaxDepth() {
         return maxDepth;
     }
 
     @Override
     public void setMaxDepth(Double maxDepth) {
         Double oldValue = getMaxDepth();
         this.maxDepth = maxDepth;
         firePropertyChange(PROPERTY_MAX_DEPTH, oldValue, maxDepth);
     }
 
     @Override
     public Integer getIndividualCount() {
         return individualCount;
     }
 
     @Override
     public void setIndividualCount(Integer individualCount) {
         Integer oldValue = getIndividualCount();
         this.individualCount = individualCount;
         firePropertyChange(PROPERTY_INDIVIDUAL_COUNT, oldValue, individualCount);
     }
 
     @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 boolean isDirty() {
         return dirty;
     }
 
     @Override
     public void setDirty(boolean dirty) {
         boolean oldValue = isDirty();
         this.dirty = dirty;
         firePropertyChange(PROPERTY_DIRTY, oldValue, dirty);
     }
 
     @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 isIndividualMeasurementsLoaded() {
         return individualMeasurementsLoaded;
     }
 
     @Override
     public void setIndividualMeasurementsLoaded(boolean individualMeasurementsLoaded) {
         boolean oldValue = isIndividualMeasurementsLoaded();
         this.individualMeasurementsLoaded = individualMeasurementsLoaded;
         firePropertyChange(PROPERTY_INDIVIDUAL_MEASUREMENTS_LOADED, oldValue, individualMeasurementsLoaded);
     }
 
     @Override
     public SamplingEquipmentDTO getSamplingEquipment() {
         return samplingEquipment;
     }
 
     @Override
     public void setSamplingEquipment(SamplingEquipmentDTO samplingEquipment) {
         SamplingEquipmentDTO oldValue = getSamplingEquipment();
         this.samplingEquipment = samplingEquipment;
         firePropertyChange(PROPERTY_SAMPLING_EQUIPMENT, oldValue, samplingEquipment);
     }
 
     @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 CoordinateDTO getCoordinate() {
         return coordinate;
     }
 
     @Override
     public void setCoordinate(CoordinateDTO coordinate) {
         CoordinateDTO oldValue = getCoordinate();
         this.coordinate = coordinate;
         firePropertyChange(PROPERTY_COORDINATE, oldValue, coordinate);
     }
 
     @Override
     public LevelDTO getDepthLevel() {
         return depthLevel;
     }
 
     @Override
     public void setDepthLevel(LevelDTO depthLevel) {
         LevelDTO oldValue = getDepthLevel();
         this.depthLevel = depthLevel;
         firePropertyChange(PROPERTY_DEPTH_LEVEL, oldValue, depthLevel);
     }
 
     @Override
     public DepartmentDTO getSamplingDepartment() {
         return samplingDepartment;
     }
 
     @Override
     public void setSamplingDepartment(DepartmentDTO samplingDepartment) {
         DepartmentDTO oldValue = getSamplingDepartment();
         this.samplingDepartment = samplingDepartment;
         firePropertyChange(PROPERTY_SAMPLING_DEPARTMENT, oldValue, samplingDepartment);
     }
 
     @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 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 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 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 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);
     }
 
 } //AbstractSamplingOperationDTOBean