package fr.ifremer.tutti.persistence.entities.protocol;
   
   /*
    * #%L
    * Tutti :: Persistence
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2012 - 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU General Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/gpl-3.0.html>.
   * #L%
   */
  
  import fr.ifremer.tutti.persistence.entities.TuttiEntityBean;
  import java.util.Collection;
  import java.util.LinkedList;
  import java.util.List;
  import javax.annotation.Generated;
  
  @Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Fri Jan 06 18:31:47 CET 2017")
  public abstract class AbstractTuttiProtocolBean extends TuttiEntityBean implements TuttiProtocol {
  
      private static final long serialVersionUID = 3847260679792845110L;
  
      protected String name;
  
      protected String comment;
  
      protected List<String> lengthClassesPmfmId;
  
      protected List<String> individualObservationPmfmId;
  
      protected Integer version;
  
      protected Collection<String> importColumns;
  
      protected String programId;
  
      protected boolean useCalcifiedPieceSampling;
  
      protected List<SpeciesProtocol> species;
  
      protected List<SpeciesProtocol> benthos;
  
      protected List<CaracteristicMappingRow> caracteristicMapping;
  
      protected Collection<OperationFieldMappingRow> operationFieldMapping;
  
      protected Collection<Zone> zone;
  
      protected List<MaturityCaracteristic> maturityCaracteristics;
  
      @Override
      public String getName() {
          return name;
      }
  
      @Override
      public void setName(String name) {
          this.name = name;
      }
  
      @Override
      public String getComment() {
          return comment;
      }
  
      @Override
      public void setComment(String comment) {
          this.comment = comment;
      }
  
      @Override
      public String getLengthClassesPmfmId(int index) {
          String o = getChild(lengthClassesPmfmId, index);
          return o;
      }
  
      @Override
      public boolean isLengthClassesPmfmIdEmpty() {
          return lengthClassesPmfmId == null || lengthClassesPmfmId.isEmpty();
      }
  
      @Override
      public int sizeLengthClassesPmfmId() {
          return lengthClassesPmfmId == null ? 0 : lengthClassesPmfmId.size();
     }
 
     @Override
     public void addLengthClassesPmfmId(String lengthClassesPmfmId) {
         getLengthClassesPmfmId().add(lengthClassesPmfmId);
     }
 
     @Override
     public void addAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId) {
         getLengthClassesPmfmId().addAll(lengthClassesPmfmId);
     }
 
     @Override
     public boolean removeLengthClassesPmfmId(String lengthClassesPmfmId) {
         boolean removed = getLengthClassesPmfmId().remove(lengthClassesPmfmId);
         return removed;
     }
 
     @Override
     public boolean removeAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId) {
         boolean  removed = getLengthClassesPmfmId().removeAll(lengthClassesPmfmId);
         return removed;
     }
 
     @Override
     public boolean containsLengthClassesPmfmId(String lengthClassesPmfmId) {
         boolean contains = getLengthClassesPmfmId().contains(lengthClassesPmfmId);
         return contains;
     }
 
     @Override
     public boolean containsAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId) {
         boolean  contains = getLengthClassesPmfmId().containsAll(lengthClassesPmfmId);
         return contains;
     }
 
     @Override
     public List<String> getLengthClassesPmfmId() {
     if (lengthClassesPmfmId == null) {
         lengthClassesPmfmId = new LinkedList<String>();
     }
     return lengthClassesPmfmId;
 }
 
     @Override
     public void setLengthClassesPmfmId(List<String> lengthClassesPmfmId) {
         this.lengthClassesPmfmId = lengthClassesPmfmId;
     }
 
     @Override
     public String getIndividualObservationPmfmId(int index) {
         String o = getChild(individualObservationPmfmId, index);
         return o;
     }
 
     @Override
     public boolean isIndividualObservationPmfmIdEmpty() {
         return individualObservationPmfmId == null || individualObservationPmfmId.isEmpty();
     }
 
     @Override
     public int sizeIndividualObservationPmfmId() {
         return individualObservationPmfmId == null ? 0 : individualObservationPmfmId.size();
     }
 
     @Override
     public void addIndividualObservationPmfmId(String individualObservationPmfmId) {
         getIndividualObservationPmfmId().add(individualObservationPmfmId);
     }
 
     @Override
     public void addAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId) {
         getIndividualObservationPmfmId().addAll(individualObservationPmfmId);
     }
 
     @Override
     public boolean removeIndividualObservationPmfmId(String individualObservationPmfmId) {
         boolean removed = getIndividualObservationPmfmId().remove(individualObservationPmfmId);
         return removed;
     }
 
     @Override
     public boolean removeAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId) {
         boolean  removed = getIndividualObservationPmfmId().removeAll(individualObservationPmfmId);
         return removed;
     }
 
     @Override
     public boolean containsIndividualObservationPmfmId(String individualObservationPmfmId) {
         boolean contains = getIndividualObservationPmfmId().contains(individualObservationPmfmId);
         return contains;
     }
 
     @Override
     public boolean containsAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId) {
         boolean  contains = getIndividualObservationPmfmId().containsAll(individualObservationPmfmId);
         return contains;
     }
 
     @Override
     public List<String> getIndividualObservationPmfmId() {
     if (individualObservationPmfmId == null) {
         individualObservationPmfmId = new LinkedList<String>();
     }
     return individualObservationPmfmId;
 }
 
     @Override
     public void setIndividualObservationPmfmId(List<String> individualObservationPmfmId) {
         this.individualObservationPmfmId = individualObservationPmfmId;
     }
 
     @Override
     public Integer getVersion() {
         return version;
     }
 
     @Override
     public void setVersion(Integer version) {
         this.version = version;
     }
 
     @Override
     public String getImportColumns(int index) {
         String o = getChild(importColumns, index);
         return o;
     }
 
     @Override
     public boolean isImportColumnsEmpty() {
         return importColumns == null || importColumns.isEmpty();
     }
 
     @Override
     public int sizeImportColumns() {
         return importColumns == null ? 0 : importColumns.size();
     }
 
     @Override
     public void addImportColumns(String importColumns) {
         getImportColumns().add(importColumns);
     }
 
     @Override
     public void addAllImportColumns(Collection<String> importColumns) {
         getImportColumns().addAll(importColumns);
     }
 
     @Override
     public boolean removeImportColumns(String importColumns) {
         boolean removed = getImportColumns().remove(importColumns);
         return removed;
     }
 
     @Override
     public boolean removeAllImportColumns(Collection<String> importColumns) {
         boolean  removed = getImportColumns().removeAll(importColumns);
         return removed;
     }
 
     @Override
     public boolean containsImportColumns(String importColumns) {
         boolean contains = getImportColumns().contains(importColumns);
         return contains;
     }
 
     @Override
     public boolean containsAllImportColumns(Collection<String> importColumns) {
         boolean  contains = getImportColumns().containsAll(importColumns);
         return contains;
     }
 
     @Override
     public Collection<String> getImportColumns() {
     if (importColumns == null) {
         importColumns = new LinkedList<String>();
     }
     return importColumns;
 }
 
     @Override
     public void setImportColumns(Collection<String> importColumns) {
         this.importColumns = importColumns;
     }
 
     @Override
     public String getProgramId() {
         return programId;
     }
 
     @Override
     public void setProgramId(String programId) {
         this.programId = programId;
     }
 
     @Override
     public boolean isUseCalcifiedPieceSampling() {
         return useCalcifiedPieceSampling;
     }
 
     @Override
     public void setUseCalcifiedPieceSampling(boolean useCalcifiedPieceSampling) {
         this.useCalcifiedPieceSampling = useCalcifiedPieceSampling;
     }
 
     @Override
     public SpeciesProtocol getSpecies(int index) {
         SpeciesProtocol o = getChild(species, index);
         return o;
     }
 
     @Override
     public boolean isSpeciesEmpty() {
         return species == null || species.isEmpty();
     }
 
     @Override
     public int sizeSpecies() {
         return species == null ? 0 : species.size();
     }
 
     @Override
     public void addSpecies(SpeciesProtocol species) {
         getSpecies().add(species);
     }
 
     @Override
     public void addAllSpecies(Collection<SpeciesProtocol> species) {
         getSpecies().addAll(species);
     }
 
     @Override
     public boolean removeSpecies(SpeciesProtocol species) {
         boolean removed = getSpecies().remove(species);
         return removed;
     }
 
     @Override
     public boolean removeAllSpecies(Collection<SpeciesProtocol> species) {
         boolean  removed = getSpecies().removeAll(species);
         return removed;
     }
 
     @Override
     public boolean containsSpecies(SpeciesProtocol species) {
         boolean contains = getSpecies().contains(species);
         return contains;
     }
 
     @Override
     public boolean containsAllSpecies(Collection<SpeciesProtocol> species) {
         boolean  contains = getSpecies().containsAll(species);
         return contains;
     }
 
     @Override
     public List<SpeciesProtocol> getSpecies() {
     if (species == null) {
         species = new LinkedList<SpeciesProtocol>();
     }
     return species;
 }
 
     @Override
     public void setSpecies(List<SpeciesProtocol> species) {
         this.species = species;
     }
 
     @Override
     public SpeciesProtocol getBenthos(int index) {
         SpeciesProtocol o = getChild(benthos, index);
         return o;
     }
 
     @Override
     public boolean isBenthosEmpty() {
         return benthos == null || benthos.isEmpty();
     }
 
     @Override
     public int sizeBenthos() {
         return benthos == null ? 0 : benthos.size();
     }
 
     @Override
     public void addBenthos(SpeciesProtocol benthos) {
         getBenthos().add(benthos);
     }
 
     @Override
     public void addAllBenthos(Collection<SpeciesProtocol> benthos) {
         getBenthos().addAll(benthos);
     }
 
     @Override
     public boolean removeBenthos(SpeciesProtocol benthos) {
         boolean removed = getBenthos().remove(benthos);
         return removed;
     }
 
     @Override
     public boolean removeAllBenthos(Collection<SpeciesProtocol> benthos) {
         boolean  removed = getBenthos().removeAll(benthos);
         return removed;
     }
 
     @Override
     public boolean containsBenthos(SpeciesProtocol benthos) {
         boolean contains = getBenthos().contains(benthos);
         return contains;
     }
 
     @Override
     public boolean containsAllBenthos(Collection<SpeciesProtocol> benthos) {
         boolean  contains = getBenthos().containsAll(benthos);
         return contains;
     }
 
     @Override
     public List<SpeciesProtocol> getBenthos() {
     if (benthos == null) {
         benthos = new LinkedList<SpeciesProtocol>();
     }
     return benthos;
 }
 
     @Override
     public void setBenthos(List<SpeciesProtocol> benthos) {
         this.benthos = benthos;
     }
 
     @Override
     public CaracteristicMappingRow getCaracteristicMapping(int index) {
         CaracteristicMappingRow o = getChild(caracteristicMapping, index);
         return o;
     }
 
     @Override
     public boolean isCaracteristicMappingEmpty() {
         return caracteristicMapping == null || caracteristicMapping.isEmpty();
     }
 
     @Override
     public int sizeCaracteristicMapping() {
         return caracteristicMapping == null ? 0 : caracteristicMapping.size();
     }
 
     @Override
     public void addCaracteristicMapping(CaracteristicMappingRow caracteristicMapping) {
         getCaracteristicMapping().add(caracteristicMapping);
     }
 
     @Override
     public void addAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping) {
         getCaracteristicMapping().addAll(caracteristicMapping);
     }
 
     @Override
     public boolean removeCaracteristicMapping(CaracteristicMappingRow caracteristicMapping) {
         boolean removed = getCaracteristicMapping().remove(caracteristicMapping);
         return removed;
     }
 
     @Override
     public boolean removeAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping) {
         boolean  removed = getCaracteristicMapping().removeAll(caracteristicMapping);
         return removed;
     }
 
     @Override
     public boolean containsCaracteristicMapping(CaracteristicMappingRow caracteristicMapping) {
         boolean contains = getCaracteristicMapping().contains(caracteristicMapping);
         return contains;
     }
 
     @Override
     public boolean containsAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping) {
         boolean  contains = getCaracteristicMapping().containsAll(caracteristicMapping);
         return contains;
     }
 
     @Override
     public List<CaracteristicMappingRow> getCaracteristicMapping() {
     if (caracteristicMapping == null) {
         caracteristicMapping = new LinkedList<CaracteristicMappingRow>();
     }
     return caracteristicMapping;
 }
 
     @Override
     public void setCaracteristicMapping(List<CaracteristicMappingRow> caracteristicMapping) {
         this.caracteristicMapping = caracteristicMapping;
     }
 
     @Override
     public OperationFieldMappingRow getOperationFieldMapping(int index) {
         OperationFieldMappingRow o = getChild(operationFieldMapping, index);
         return o;
     }
 
     @Override
     public boolean isOperationFieldMappingEmpty() {
         return operationFieldMapping == null || operationFieldMapping.isEmpty();
     }
 
     @Override
     public int sizeOperationFieldMapping() {
         return operationFieldMapping == null ? 0 : operationFieldMapping.size();
     }
 
     @Override
     public void addOperationFieldMapping(OperationFieldMappingRow operationFieldMapping) {
         getOperationFieldMapping().add(operationFieldMapping);
     }
 
     @Override
     public void addAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping) {
         getOperationFieldMapping().addAll(operationFieldMapping);
     }
 
     @Override
     public boolean removeOperationFieldMapping(OperationFieldMappingRow operationFieldMapping) {
         boolean removed = getOperationFieldMapping().remove(operationFieldMapping);
         return removed;
     }
 
     @Override
     public boolean removeAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping) {
         boolean  removed = getOperationFieldMapping().removeAll(operationFieldMapping);
         return removed;
     }
 
     @Override
     public boolean containsOperationFieldMapping(OperationFieldMappingRow operationFieldMapping) {
         boolean contains = getOperationFieldMapping().contains(operationFieldMapping);
         return contains;
     }
 
     @Override
     public boolean containsAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping) {
         boolean  contains = getOperationFieldMapping().containsAll(operationFieldMapping);
         return contains;
     }
 
     @Override
     public Collection<OperationFieldMappingRow> getOperationFieldMapping() {
     if (operationFieldMapping == null) {
         operationFieldMapping = new LinkedList<OperationFieldMappingRow>();
     }
     return operationFieldMapping;
 }
 
     @Override
     public void setOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping) {
         this.operationFieldMapping = operationFieldMapping;
     }
 
     @Override
     public Zone getZone(int index) {
         Zone o = getChild(zone, index);
         return o;
     }
 
     @Override
     public boolean isZoneEmpty() {
         return zone == null || zone.isEmpty();
     }
 
     @Override
     public int sizeZone() {
         return zone == null ? 0 : zone.size();
     }
 
     @Override
     public void addZone(Zone zone) {
         getZone().add(zone);
     }
 
     @Override
     public void addAllZone(Collection<Zone> zone) {
         getZone().addAll(zone);
     }
 
     @Override
     public boolean removeZone(Zone zone) {
         boolean removed = getZone().remove(zone);
         return removed;
     }
 
     @Override
     public boolean removeAllZone(Collection<Zone> zone) {
         boolean  removed = getZone().removeAll(zone);
         return removed;
     }
 
     @Override
     public boolean containsZone(Zone zone) {
         boolean contains = getZone().contains(zone);
         return contains;
     }
 
     @Override
     public boolean containsAllZone(Collection<Zone> zone) {
         boolean  contains = getZone().containsAll(zone);
         return contains;
     }
 
     @Override
     public Collection<Zone> getZone() {
     if (zone == null) {
         zone = new LinkedList<Zone>();
     }
     return zone;
 }
 
     @Override
     public void setZone(Collection<Zone> zone) {
         this.zone = zone;
     }
 
     @Override
     public MaturityCaracteristic getMaturityCaracteristics(int index) {
         MaturityCaracteristic o = getChild(maturityCaracteristics, index);
         return o;
     }
 
     @Override
     public boolean isMaturityCaracteristicsEmpty() {
         return maturityCaracteristics == null || maturityCaracteristics.isEmpty();
     }
 
     @Override
     public int sizeMaturityCaracteristics() {
         return maturityCaracteristics == null ? 0 : maturityCaracteristics.size();
     }
 
     @Override
     public void addMaturityCaracteristics(MaturityCaracteristic maturityCaracteristics) {
         getMaturityCaracteristics().add(maturityCaracteristics);
     }
 
     @Override
     public void addAllMaturityCaracteristics(Collection<MaturityCaracteristic> maturityCaracteristics) {
         getMaturityCaracteristics().addAll(maturityCaracteristics);
     }
 
     @Override
     public boolean removeMaturityCaracteristics(MaturityCaracteristic maturityCaracteristics) {
         boolean removed = getMaturityCaracteristics().remove(maturityCaracteristics);
         return removed;
     }
 
     @Override
     public boolean removeAllMaturityCaracteristics(Collection<MaturityCaracteristic> maturityCaracteristics) {
         boolean  removed = getMaturityCaracteristics().removeAll(maturityCaracteristics);
         return removed;
     }
 
     @Override
     public boolean containsMaturityCaracteristics(MaturityCaracteristic maturityCaracteristics) {
         boolean contains = getMaturityCaracteristics().contains(maturityCaracteristics);
         return contains;
     }
 
     @Override
     public boolean containsAllMaturityCaracteristics(Collection<MaturityCaracteristic> maturityCaracteristics) {
         boolean  contains = getMaturityCaracteristics().containsAll(maturityCaracteristics);
         return contains;
     }
 
     @Override
     public List<MaturityCaracteristic> getMaturityCaracteristics() {
     if (maturityCaracteristics == null) {
         maturityCaracteristics = new LinkedList<MaturityCaracteristic>();
     }
     return maturityCaracteristics;
 }
 
     @Override
     public void setMaturityCaracteristics(List<MaturityCaracteristic> maturityCaracteristics) {
         this.maturityCaracteristics = maturityCaracteristics;
     }
 
 } //AbstractTuttiProtocolBean