[Tutti-commits] 05/11: migration du protocole (refs #8013)

24 Feb 2016

This is an automated email from the git hooks/post-receive script.

New commit to branch feature/8013 in repository tutti.

See http://git.codelutin.com/tutti.git

commit 98eaf874bb9cac8ff073220b836321aa34d0fa50
Author: Kevin Morin <morin@codelutin.com>
Date:   Wed Feb 24 15:59:36 2016 +0100

    migration du protocole (refs #8013)
---
 .../entities/protocol/TuttiProtocols.java          | 108 +++-
 .../entities/protocol/v3/SpeciesProtocol3.java     | 150 ++++++
 .../entities/protocol/v3/SpeciesProtocolBean3.java | 330 ++++++++++++
 .../entities/protocol/v3/TuttiProtocol3.java       | 238 ++++++++
 .../entities/protocol/v3/TuttiProtocolBean3.java   | 598 +++++++++++++++++++++
 5 files changed, 1413 insertions(+), 11 deletions(-)

diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java
index 9168b1f..dedda90 100644
--- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/TuttiProtocols.java
@@ -42,6 +42,10 @@ import fr.ifremer.tutti.persistence.entities.protocol.v1.TuttiProtocol1;
 import fr.ifremer.tutti.persistence.entities.protocol.v1.TuttiProtocolBean1;
 import fr.ifremer.tutti.persistence.entities.protocol.v2.TuttiProtocol2;
 import fr.ifremer.tutti.persistence.entities.protocol.v2.TuttiProtocolBean2;
+import fr.ifremer.tutti.persistence.entities.protocol.v3.SpeciesProtocol3;
+import fr.ifremer.tutti.persistence.entities.protocol.v3.SpeciesProtocolBean3;
+import fr.ifremer.tutti.persistence.entities.protocol.v3.TuttiProtocol3;
+import fr.ifremer.tutti.persistence.entities.protocol.v3.TuttiProtocolBean3;
 import fr.ifremer.tutti.persistence.entities.referential.Caracteristic;
 import fr.ifremer.tutti.persistence.entities.referential.Species;
 import fr.ifremer.tutti.persistence.entities.referential.Speciess;
@@ -115,6 +119,9 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
             }
 
         } catch (Exception e) {
+            if (log.isInfoEnabled()) {
+                log.info("Protocol needs to be migrated", e);
+            }
             result = migrateProtocol(file);
 
         } finally {
@@ -180,20 +187,39 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
 
     protected static TuttiProtocol migrateProtocol(File file) {
         try {
-            //try to load a v2
-            TuttiProtocol2 tuttiProtocol2 = fromFileV2(file);
+            //try to load a v3
+            TuttiProtocol3 tuttiProtocol3 = fromFileV3(file);
 
-            TuttiProtocol result = fromTuttiProtocol2(tuttiProtocol2);
+            TuttiProtocol result = fromTuttiProtocol3(tuttiProtocol3);
             return result;
 
         } catch (Exception ee) {
-            // try to load a v1
-            TuttiProtocol1 tuttiProtocol1 = fromFileV1(file);
+            if (log.isErrorEnabled()) {
+                log.error("Error on loading a v3", ee);
+            }
+            try {
+                //try to load a v2
+                TuttiProtocol2 tuttiProtocol2 = fromFileV2(file);
 
-            TuttiProtocol2 tuttiProtocol2 = fromTuttiProtocol1(tuttiProtocol1);
+                TuttiProtocol3 tuttiProtocol3 = fromTuttiProtocol2(tuttiProtocol2);
 
-            TuttiProtocol result = fromTuttiProtocol2(tuttiProtocol2);
-            return result;
+                TuttiProtocol result = fromTuttiProtocol3(tuttiProtocol3);
+                return result;
+
+            } catch (Exception ee2) {
+                if (log.isErrorEnabled()) {
+                    log.error("Error on loading a v2", ee2);
+                }
+                // try to load a v1
+                TuttiProtocol1 tuttiProtocol1 = fromFileV1(file);
+
+                TuttiProtocol2 tuttiProtocol2 = fromTuttiProtocol1(tuttiProtocol1);
+
+                TuttiProtocol3 tuttiProtocol3 = fromTuttiProtocol2(tuttiProtocol2);
+
+                TuttiProtocol result = fromTuttiProtocol3(tuttiProtocol3);
+                return result;
+            }
         }
     }
 
@@ -229,6 +255,22 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
         }
     }
 
+    public static TuttiProtocol3 fromFileV3(File file) {
+
+        Reader fileReader = null;
+        try {
+            fileReader = Files.newReader(file, Charsets.UTF_8);
+            YamlReader reader = new YamlReader(fileReader, createConfigV3());
+            TuttiProtocol3 result = reader.read(TuttiProtocolBean3.class);
+            fileReader.close();
+            return result;
+        } catch (Exception e) {
+            throw new ApplicationTechnicalException(t("tutti.persistence.protocol.fromFile.error", file), e);
+        } finally {
+            IOUtils.closeQuietly(fileReader);
+        }
+    }
+
     public static void checkSampleCategories(SampleCategoryModel sampleCategoryModel,
                                              TuttiProtocol protocol,
                                              Set<Integer> badCategories) {
@@ -345,9 +387,9 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
         return result;
     }
 
-    protected static TuttiProtocol fromTuttiProtocol2(TuttiProtocol2 tuttiProtocol2) {
-        TuttiProtocol result = newTuttiProtocol();
-        Binder<TuttiProtocol2, TuttiProtocol> binder = BinderFactory.newBinder(TuttiProtocol2.class, TuttiProtocol.class);
+    protected static TuttiProtocol3 fromTuttiProtocol2(TuttiProtocol2 tuttiProtocol2) {
+        TuttiProtocol3 result = new TuttiProtocolBean3();
+        Binder<TuttiProtocol2, TuttiProtocol3> binder = BinderFactory.newBinder(TuttiProtocol2.class, TuttiProtocol3.class);
         binder.copy(tuttiProtocol2, result);
 
         List<CaracteristicMappingRow> caracteristicMappingRows = new ArrayList<>();
@@ -370,6 +412,35 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
         return result;
     }
 
+    protected static TuttiProtocol fromTuttiProtocol3(TuttiProtocol3 tuttiProtocol3) {
+        TuttiProtocol result = newTuttiProtocol();
+        Binder<TuttiProtocol3, TuttiProtocol> binder = BinderFactory.newBinder(TuttiProtocol3.class, TuttiProtocol.class);
+        binder.copy(tuttiProtocol3, result);
+
+        if (!tuttiProtocol3.isSpeciesEmpty()) {
+            result.setSpecies(Lists.<SpeciesProtocol>newArrayList());
+            Binder<SpeciesProtocol3, SpeciesProtocol> binderSpecies = BinderFactory.newBinder(SpeciesProtocol3.class, SpeciesProtocol.class);
+            for (SpeciesProtocol3 speciesProtocol3 : tuttiProtocol3.getSpecies()) {
+                SpeciesProtocol row = SpeciesProtocols.newSpeciesProtocol();
+                row.setMandatorySampleCategoryId(Lists.<Integer>newArrayList());
+                binderSpecies.copy(speciesProtocol3, row);
+                result.addSpecies(row);
+            }
+        }
+        if (!tuttiProtocol3.isBenthosEmpty()) {
+            result.setBenthos(Lists.<SpeciesProtocol>newArrayList());
+            Binder<SpeciesProtocol3, SpeciesProtocol> binderSpecies = BinderFactory.newBinder(SpeciesProtocol3.class, SpeciesProtocol.class);
+            for (SpeciesProtocol3 speciesProtocol3 : tuttiProtocol3.getBenthos()) {
+                SpeciesProtocol row = SpeciesProtocols.newSpeciesProtocol();
+                row.setMandatorySampleCategoryId(Lists.<Integer>newArrayList());
+                binderSpecies.copy(speciesProtocol3, row);
+                result.addBenthos(row);
+            }
+        }
+
+        return result;
+    }
+
     protected static YamlConfig createConfig() {
         YamlConfig result = new YamlConfig();
         result.setClassTag(SpeciesProtocol.class.getSimpleName(),
@@ -404,6 +475,21 @@ public class TuttiProtocols extends AbstractTuttiProtocols {
         return result;
     }
 
+    protected static YamlConfig createConfigV3() {
+        YamlConfig result = new YamlConfig();
+        result.setClassTag(SpeciesProtocol.class.getSimpleName(), SpeciesProtocolBean3.class);
+        result.setClassTag(CaracteristicMappingRow.class.getSimpleName(),
+                           CaracteristicMappingRows.typeOfCaracteristicMappingRow());
+        result.setClassTag(Zone.class.getSimpleName(), Zones.typeOfZone());
+        result.setClassTag(Strata.class.getSimpleName(), Stratas.typeOfStrata());
+        result.setClassTag(SubStrata.class.getSimpleName(), SubStratas.typeOfSubStrata());
+        result.setClassTag(CalcifiedPiecesSamplingDefinition.class.getSimpleName(),
+                           CalcifiedPiecesSamplingDefinitions.typeOfCalcifiedPiecesSamplingDefinition());
+        result.writeConfig.setAlwaysWriteClassname(false);
+        result.writeConfig.setWriteRootTags(false);
+        return result;
+    }
+
     public static SpeciesProtocol getSpeciesOrBenthosProtocol(TuttiProtocol protocol, Integer speciesReferenceTaxonId) {
         SpeciesProtocol speciesProtocol = getSpeciesProtocol(protocol, speciesReferenceTaxonId);
         if (speciesProtocol == null) {
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocol3.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocol3.java
new file mode 100644
index 0000000..5cf0ddd
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocol3.java
@@ -0,0 +1,150 @@
+package fr.ifremer.tutti.persistence.entities.protocol.v3;
+
+import fr.ifremer.tutti.persistence.entities.TuttiEntity;
+import fr.ifremer.tutti.persistence.entities.protocol.CalcifiedPiecesSamplingDefinition;
+import fr.ifremer.tutti.persistence.entities.protocol.Rtp;
+
+import javax.annotation.Generated;
+import java.util.Collection;
+import java.util.List;
+
+@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Wed Feb 24 14:48:37 CET 2016")
+public interface SpeciesProtocol3 extends TuttiEntity {
+
+    String PROPERTY_SPECIES_REFERENCE_TAXON_ID = "speciesReferenceTaxonId";
+
+    String PROPERTY_SPECIES_SURVEY_CODE = "speciesSurveyCode";
+
+    String PROPERTY_LENGTH_STEP_PMFM_ID = "lengthStepPmfmId";
+
+    String PROPERTY_WEIGHT_ENABLED = "weightEnabled";
+
+    String PROPERTY_COUNT_IF_NO_FREQUENCY_ENABLED = "countIfNoFrequencyEnabled";
+
+    String PROPERTY_CALCIFY_SAMPLE_ENABLED = "calcifySampleEnabled";
+
+    String PROPERTY_LENGTH_STEP = "lengthStep";
+
+    String PROPERTY_MADE_FROM_AREFERENT_TAXON = "madeFromAReferentTaxon";
+
+    String PROPERTY_MANDATORY_SAMPLE_CATEGORY_ID = "mandatorySampleCategoryId";
+
+    String PROPERTY_RTP_MALE = "rtpMale";
+
+    String PROPERTY_RTP_FEMALE = "rtpFemale";
+
+    String PROPERTY_RTP_UNDEFINED = "rtpUndefined";
+
+    String PROPERTY_INDIVIDUAL_OBSERVATION_ENABLED = "individualObservationEnabled";
+
+    String PROPERTY_MATURITY_PMFM_ID = "maturityPmfmId";
+
+    String PROPERTY_CALCIFIED_PIECES_SAMPLING_DEFINITION = "calcifiedPiecesSamplingDefinition";
+
+    Integer getSpeciesReferenceTaxonId();
+
+    void setSpeciesReferenceTaxonId(Integer speciesReferenceTaxonId);
+
+    String getSpeciesSurveyCode();
+
+    void setSpeciesSurveyCode(String speciesSurveyCode);
+
+    String getLengthStepPmfmId();
+
+    void setLengthStepPmfmId(String lengthStepPmfmId);
+
+    boolean isWeightEnabled();
+
+    void setWeightEnabled(boolean weightEnabled);
+
+    boolean isCountIfNoFrequencyEnabled();
+
+    void setCountIfNoFrequencyEnabled(boolean countIfNoFrequencyEnabled);
+
+    boolean isCalcifySampleEnabled();
+
+    void setCalcifySampleEnabled(boolean calcifySampleEnabled);
+
+    Float getLengthStep();
+
+    void setLengthStep(Float lengthStep);
+
+    boolean isMadeFromAReferentTaxon();
+
+    void setMadeFromAReferentTaxon(boolean madeFromAReferentTaxon);
+
+    Integer getMandatorySampleCategoryId(int index);
+
+    boolean isMandatorySampleCategoryIdEmpty();
+
+    int sizeMandatorySampleCategoryId();
+
+    void addMandatorySampleCategoryId(Integer mandatorySampleCategoryId);
+
+    void addAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId);
+
+    boolean removeMandatorySampleCategoryId(Integer mandatorySampleCategoryId);
+
+    boolean removeAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId);
+
+    boolean containsMandatorySampleCategoryId(Integer mandatorySampleCategoryId);
+
+    boolean containsAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId);
+
+    List<Integer> getMandatorySampleCategoryId();
+
+    void setMandatorySampleCategoryId(List<Integer> mandatorySampleCategoryId);
+
+    Rtp getRtpMale();
+
+    void setRtpMale(Rtp rtpMale);
+
+    Rtp getRtpFemale();
+
+    void setRtpFemale(Rtp rtpFemale);
+
+    Rtp getRtpUndefined();
+
+    void setRtpUndefined(Rtp rtpUndefined);
+
+    boolean isIndividualObservationEnabled();
+
+    void setIndividualObservationEnabled(boolean individualObservationEnabled);
+
+    String getMaturityPmfmId();
+
+    void setMaturityPmfmId(String maturityPmfmId);
+
+    String getCalcifiedPiecesSamplingTypePmfmId();
+
+    void setCalcifiedPiecesSamplingTypePmfmId(String calcifiedPiecesSamplingTypePmfmId);
+
+    CalcifiedPiecesSamplingDefinition getCalcifiedPiecesSamplingDefinition(int index);
+
+    boolean isCalcifiedPiecesSamplingDefinitionEmpty();
+
+    int sizeCalcifiedPiecesSamplingDefinition();
+
+    void addCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition);
+
+    void addAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition);
+
+    boolean removeCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition);
+
+    boolean removeAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition);
+
+    boolean containsCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition);
+
+    boolean containsAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition);
+
+    Collection<CalcifiedPiecesSamplingDefinition> getCalcifiedPiecesSamplingDefinition();
+
+    void setCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition);
+
+    boolean withRtpMale();
+
+    boolean withRtpFemale();
+
+    boolean withRtpUndefined();
+
+} //SpeciesProtocol
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocolBean3.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocolBean3.java
new file mode 100644
index 0000000..648b76f
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/SpeciesProtocolBean3.java
@@ -0,0 +1,330 @@
+package fr.ifremer.tutti.persistence.entities.protocol.v3;
+
+import fr.ifremer.tutti.persistence.entities.TuttiEntityBean;
+import fr.ifremer.tutti.persistence.entities.protocol.CalcifiedPiecesSamplingDefinition;
+import fr.ifremer.tutti.persistence.entities.protocol.Rtp;
+
+import javax.annotation.Generated;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Wed Feb 24 14:48:37 CET 2016")
+public class SpeciesProtocolBean3 extends TuttiEntityBean implements SpeciesProtocol3 {
+
+    private static final long serialVersionUID = 3486411950096802662L;
+
+    protected Integer speciesReferenceTaxonId;
+
+    protected String speciesSurveyCode;
+
+    protected String lengthStepPmfmId;
+
+    protected boolean weightEnabled;
+
+    protected boolean countIfNoFrequencyEnabled;
+
+    protected boolean calcifySampleEnabled;
+
+    protected Float lengthStep;
+
+    protected boolean madeFromAReferentTaxon;
+
+    protected List<Integer> mandatorySampleCategoryId;
+
+    protected Rtp rtpMale;
+
+    protected Rtp rtpFemale;
+
+    protected Rtp rtpUndefined;
+
+    protected boolean individualObservationEnabled;
+
+    protected String maturityPmfmId;
+
+    protected String calcifiedPiecesSamplingTypePmfmId;
+
+    protected Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition;
+
+    @Override
+    public Integer getSpeciesReferenceTaxonId() {
+        return speciesReferenceTaxonId;
+    }
+
+    @Override
+    public void setSpeciesReferenceTaxonId(Integer speciesReferenceTaxonId) {
+        this.speciesReferenceTaxonId = speciesReferenceTaxonId;
+    }
+
+    @Override
+    public String getSpeciesSurveyCode() {
+        return speciesSurveyCode;
+    }
+
+    @Override
+    public void setSpeciesSurveyCode(String speciesSurveyCode) {
+        this.speciesSurveyCode = speciesSurveyCode;
+    }
+
+    @Override
+    public String getLengthStepPmfmId() {
+        return lengthStepPmfmId;
+    }
+
+    @Override
+    public void setLengthStepPmfmId(String lengthStepPmfmId) {
+        this.lengthStepPmfmId = lengthStepPmfmId;
+    }
+
+    @Override
+    public boolean isWeightEnabled() {
+        return weightEnabled;
+    }
+
+    @Override
+    public void setWeightEnabled(boolean weightEnabled) {
+        this.weightEnabled = weightEnabled;
+    }
+
+    @Override
+    public boolean isCountIfNoFrequencyEnabled() {
+        return countIfNoFrequencyEnabled;
+    }
+
+    @Override
+    public void setCountIfNoFrequencyEnabled(boolean countIfNoFrequencyEnabled) {
+        this.countIfNoFrequencyEnabled = countIfNoFrequencyEnabled;
+    }
+
+    @Override
+    public boolean isCalcifySampleEnabled() {
+        return calcifySampleEnabled;
+    }
+
+    @Override
+    public void setCalcifySampleEnabled(boolean calcifySampleEnabled) {
+        this.calcifySampleEnabled = calcifySampleEnabled;
+    }
+
+    @Override
+    public Float getLengthStep() {
+        return lengthStep;
+    }
+
+    @Override
+    public void setLengthStep(Float lengthStep) {
+        this.lengthStep = lengthStep;
+    }
+
+    @Override
+    public boolean isMadeFromAReferentTaxon() {
+        return madeFromAReferentTaxon;
+    }
+
+    @Override
+    public void setMadeFromAReferentTaxon(boolean madeFromAReferentTaxon) {
+        this.madeFromAReferentTaxon = madeFromAReferentTaxon;
+    }
+
+    @Override
+    public Integer getMandatorySampleCategoryId(int index) {
+        Integer o = getChild(mandatorySampleCategoryId, index);
+        return o;
+    }
+
+    @Override
+    public boolean isMandatorySampleCategoryIdEmpty() {
+        return mandatorySampleCategoryId == null || mandatorySampleCategoryId.isEmpty();
+    }
+
+    @Override
+    public int sizeMandatorySampleCategoryId() {
+        return mandatorySampleCategoryId == null ? 0 : mandatorySampleCategoryId.size();
+    }
+
+    @Override
+    public void addMandatorySampleCategoryId(Integer mandatorySampleCategoryId) {
+        getMandatorySampleCategoryId().add(mandatorySampleCategoryId);
+    }
+
+    @Override
+    public void addAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId) {
+        getMandatorySampleCategoryId().addAll(mandatorySampleCategoryId);
+    }
+
+    @Override
+    public boolean removeMandatorySampleCategoryId(Integer mandatorySampleCategoryId) {
+        boolean removed = getMandatorySampleCategoryId().remove(mandatorySampleCategoryId);
+        return removed;
+    }
+
+    @Override
+    public boolean removeAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId) {
+        boolean  removed = getMandatorySampleCategoryId().removeAll(mandatorySampleCategoryId);
+        return removed;
+    }
+
+    @Override
+    public boolean containsMandatorySampleCategoryId(Integer mandatorySampleCategoryId) {
+        boolean contains = getMandatorySampleCategoryId().contains(mandatorySampleCategoryId);
+        return contains;
+    }
+
+    @Override
+    public boolean containsAllMandatorySampleCategoryId(Collection<Integer> mandatorySampleCategoryId) {
+        boolean  contains = getMandatorySampleCategoryId().containsAll(mandatorySampleCategoryId);
+        return contains;
+    }
+
+    @Override
+    public List<Integer> getMandatorySampleCategoryId() {
+    if (mandatorySampleCategoryId == null) {
+        mandatorySampleCategoryId = new LinkedList<Integer>();
+    }
+    return mandatorySampleCategoryId;
+}
+
+    @Override
+    public void setMandatorySampleCategoryId(List<Integer> mandatorySampleCategoryId) {
+        this.mandatorySampleCategoryId = mandatorySampleCategoryId;
+    }
+
+    @Override
+    public Rtp getRtpMale() {
+        return rtpMale;
+    }
+
+    @Override
+    public void setRtpMale(Rtp rtpMale) {
+        this.rtpMale = rtpMale;
+    }
+
+    @Override
+    public Rtp getRtpFemale() {
+        return rtpFemale;
+    }
+
+    @Override
+    public void setRtpFemale(Rtp rtpFemale) {
+        this.rtpFemale = rtpFemale;
+    }
+
+    @Override
+    public Rtp getRtpUndefined() {
+        return rtpUndefined;
+    }
+
+    @Override
+    public void setRtpUndefined(Rtp rtpUndefined) {
+        this.rtpUndefined = rtpUndefined;
+    }
+
+    @Override
+    public boolean isIndividualObservationEnabled() {
+        return individualObservationEnabled;
+    }
+
+    @Override
+    public void setIndividualObservationEnabled(boolean individualObservationEnabled) {
+        this.individualObservationEnabled = individualObservationEnabled;
+    }
+
+    @Override
+    public String getMaturityPmfmId() {
+        return maturityPmfmId;
+    }
+
+    @Override
+    public void setMaturityPmfmId(String maturityPmfmId) {
+        this.maturityPmfmId = maturityPmfmId;
+    }
+
+    @Override
+    public String getCalcifiedPiecesSamplingTypePmfmId() {
+        return calcifiedPiecesSamplingTypePmfmId;
+    }
+
+    @Override
+    public void setCalcifiedPiecesSamplingTypePmfmId(String calcifiedPiecesSamplingTypePmfmId) {
+        this.calcifiedPiecesSamplingTypePmfmId = calcifiedPiecesSamplingTypePmfmId;
+    }
+
+    @Override
+    public CalcifiedPiecesSamplingDefinition getCalcifiedPiecesSamplingDefinition(int index) {
+        CalcifiedPiecesSamplingDefinition o = getChild(calcifiedPiecesSamplingDefinition, index);
+        return o;
+    }
+
+    @Override
+    public boolean isCalcifiedPiecesSamplingDefinitionEmpty() {
+        return calcifiedPiecesSamplingDefinition == null || calcifiedPiecesSamplingDefinition.isEmpty();
+    }
+
+    @Override
+    public int sizeCalcifiedPiecesSamplingDefinition() {
+        return calcifiedPiecesSamplingDefinition == null ? 0 : calcifiedPiecesSamplingDefinition.size();
+    }
+
+    @Override
+    public void addCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition) {
+        getCalcifiedPiecesSamplingDefinition().add(calcifiedPiecesSamplingDefinition);
+    }
+
+    @Override
+    public void addAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition) {
+        getCalcifiedPiecesSamplingDefinition().addAll(calcifiedPiecesSamplingDefinition);
+    }
+
+    @Override
+    public boolean removeCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition) {
+        boolean removed = getCalcifiedPiecesSamplingDefinition().remove(calcifiedPiecesSamplingDefinition);
+        return removed;
+    }
+
+    @Override
+    public boolean removeAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition) {
+        boolean  removed = getCalcifiedPiecesSamplingDefinition().removeAll(calcifiedPiecesSamplingDefinition);
+        return removed;
+    }
+
+    @Override
+    public boolean containsCalcifiedPiecesSamplingDefinition(CalcifiedPiecesSamplingDefinition calcifiedPiecesSamplingDefinition) {
+        boolean contains = getCalcifiedPiecesSamplingDefinition().contains(calcifiedPiecesSamplingDefinition);
+        return contains;
+    }
+
+    @Override
+    public boolean containsAllCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition) {
+        boolean  contains = getCalcifiedPiecesSamplingDefinition().containsAll(calcifiedPiecesSamplingDefinition);
+        return contains;
+    }
+
+    @Override
+    public Collection<CalcifiedPiecesSamplingDefinition> getCalcifiedPiecesSamplingDefinition() {
+    if (calcifiedPiecesSamplingDefinition == null) {
+        calcifiedPiecesSamplingDefinition = new LinkedList<CalcifiedPiecesSamplingDefinition>();
+    }
+    return calcifiedPiecesSamplingDefinition;
+}
+
+    @Override
+    public void setCalcifiedPiecesSamplingDefinition(Collection<CalcifiedPiecesSamplingDefinition> calcifiedPiecesSamplingDefinition) {
+        this.calcifiedPiecesSamplingDefinition = calcifiedPiecesSamplingDefinition;
+    }
+
+    @Override
+    public boolean withRtpMale() {
+        return rtpMale != null;
+    }
+
+    @Override
+    public boolean withRtpFemale() {
+        return rtpFemale != null;
+    }
+
+    @Override
+    public boolean withRtpUndefined() {
+        return rtpUndefined != null;
+    }
+
+} //AbstractSpeciesProtocolBean
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocol3.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocol3.java
new file mode 100644
index 0000000..7688a0c
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocol3.java
@@ -0,0 +1,238 @@
+package fr.ifremer.tutti.persistence.entities.protocol.v3;
+
+import fr.ifremer.tutti.persistence.entities.CommentAware;
+import fr.ifremer.tutti.persistence.entities.TuttiEntity;
+import fr.ifremer.tutti.persistence.entities.protocol.CaracteristicMappingRow;
+import fr.ifremer.tutti.persistence.entities.protocol.OperationFieldMappingRow;
+import fr.ifremer.tutti.persistence.entities.protocol.Zone;
+
+import javax.annotation.Generated;
+import java.util.Collection;
+import java.util.List;
+
+@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Wed Feb 24 14:48:37 CET 2016")
+public interface TuttiProtocol3 extends CommentAware, TuttiEntity {
+
+    String PROPERTY_NAME = "name";
+
+    String PROPERTY_COMMENT = "comment";
+
+    String PROPERTY_LENGTH_CLASSES_PMFM_ID = "lengthClassesPmfmId";
+
+    String PROPERTY_INDIVIDUAL_OBSERVATION_PMFM_ID = "individualObservationPmfmId";
+
+    String PROPERTY_VERSION = "version";
+
+    String PROPERTY_IMPORT_COLUMNS = "importColumns";
+
+    String PROPERTY_PROGRAM_ID = "programId";
+
+    String PROPERTY_USE_CALCIFIED_PIECE_SAMPLING = "useCalcifiedPieceSampling";
+
+    String PROPERTY_SPECIES = "species";
+
+    String PROPERTY_BENTHOS = "benthos";
+
+    String PROPERTY_CARACTERISTIC_MAPPING = "caracteristicMapping";
+
+    String PROPERTY_OPERATION_FIELD_MAPPING = "operationFieldMapping";
+
+    String PROPERTY_ZONE = "zone";
+
+    String getName();
+
+    void setName(String name);
+
+    String getComment();
+
+    void setComment(String comment);
+
+    String getLengthClassesPmfmId(int index);
+
+    boolean isLengthClassesPmfmIdEmpty();
+
+    int sizeLengthClassesPmfmId();
+
+    void addLengthClassesPmfmId(String lengthClassesPmfmId);
+
+    void addAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId);
+
+    boolean removeLengthClassesPmfmId(String lengthClassesPmfmId);
+
+    boolean removeAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId);
+
+    boolean containsLengthClassesPmfmId(String lengthClassesPmfmId);
+
+    boolean containsAllLengthClassesPmfmId(Collection<String> lengthClassesPmfmId);
+
+    List<String> getLengthClassesPmfmId();
+
+    void setLengthClassesPmfmId(List<String> lengthClassesPmfmId);
+
+    String getIndividualObservationPmfmId(int index);
+
+    boolean isIndividualObservationPmfmIdEmpty();
+
+    int sizeIndividualObservationPmfmId();
+
+    void addIndividualObservationPmfmId(String individualObservationPmfmId);
+
+    void addAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId);
+
+    boolean removeIndividualObservationPmfmId(String individualObservationPmfmId);
+
+    boolean removeAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId);
+
+    boolean containsIndividualObservationPmfmId(String individualObservationPmfmId);
+
+    boolean containsAllIndividualObservationPmfmId(Collection<String> individualObservationPmfmId);
+
+    List<String> getIndividualObservationPmfmId();
+
+    void setIndividualObservationPmfmId(List<String> individualObservationPmfmId);
+
+    Integer getVersion();
+
+    void setVersion(Integer version);
+
+    String getImportColumns(int index);
+
+    boolean isImportColumnsEmpty();
+
+    int sizeImportColumns();
+
+    void addImportColumns(String importColumns);
+
+    void addAllImportColumns(Collection<String> importColumns);
+
+    boolean removeImportColumns(String importColumns);
+
+    boolean removeAllImportColumns(Collection<String> importColumns);
+
+    boolean containsImportColumns(String importColumns);
+
+    boolean containsAllImportColumns(Collection<String> importColumns);
+
+    Collection<String> getImportColumns();
+
+    void setImportColumns(Collection<String> importColumns);
+
+    String getProgramId();
+
+    void setProgramId(String programId);
+
+    boolean isUseCalcifiedPieceSampling();
+
+    void setUseCalcifiedPieceSampling(boolean useCalcifiedPieceSampling);
+
+    SpeciesProtocol3 getSpecies(int index);
+
+    boolean isSpeciesEmpty();
+
+    int sizeSpecies();
+
+    void addSpecies(SpeciesProtocol3 species);
+
+    void addAllSpecies(Collection<SpeciesProtocol3> species);
+
+    boolean removeSpecies(SpeciesProtocol3 species);
+
+    boolean removeAllSpecies(Collection<SpeciesProtocol3> species);
+
+    boolean containsSpecies(SpeciesProtocol3 species);
+
+    boolean containsAllSpecies(Collection<SpeciesProtocol3> species);
+
+    List<SpeciesProtocol3> getSpecies();
+
+    void setSpecies(List<SpeciesProtocol3> species);
+
+    SpeciesProtocol3 getBenthos(int index);
+
+    boolean isBenthosEmpty();
+
+    int sizeBenthos();
+
+    void addBenthos(SpeciesProtocol3 benthos);
+
+    void addAllBenthos(Collection<SpeciesProtocol3> benthos);
+
+    boolean removeBenthos(SpeciesProtocol3 benthos);
+
+    boolean removeAllBenthos(Collection<SpeciesProtocol3> benthos);
+
+    boolean containsBenthos(SpeciesProtocol3 benthos);
+
+    boolean containsAllBenthos(Collection<SpeciesProtocol3> benthos);
+
+    List<SpeciesProtocol3> getBenthos();
+
+    void setBenthos(List<SpeciesProtocol3> benthos);
+
+    CaracteristicMappingRow getCaracteristicMapping(int index);
+
+    boolean isCaracteristicMappingEmpty();
+
+    int sizeCaracteristicMapping();
+
+    void addCaracteristicMapping(CaracteristicMappingRow caracteristicMapping);
+
+    void addAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping);
+
+    boolean removeCaracteristicMapping(CaracteristicMappingRow caracteristicMapping);
+
+    boolean removeAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping);
+
+    boolean containsCaracteristicMapping(CaracteristicMappingRow caracteristicMapping);
+
+    boolean containsAllCaracteristicMapping(Collection<CaracteristicMappingRow> caracteristicMapping);
+
+    List<CaracteristicMappingRow> getCaracteristicMapping();
+
+    void setCaracteristicMapping(List<CaracteristicMappingRow> caracteristicMapping);
+
+    OperationFieldMappingRow getOperationFieldMapping(int index);
+
+    boolean isOperationFieldMappingEmpty();
+
+    int sizeOperationFieldMapping();
+
+    void addOperationFieldMapping(OperationFieldMappingRow operationFieldMapping);
+
+    void addAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping);
+
+    boolean removeOperationFieldMapping(OperationFieldMappingRow operationFieldMapping);
+
+    boolean removeAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping);
+
+    boolean containsOperationFieldMapping(OperationFieldMappingRow operationFieldMapping);
+
+    boolean containsAllOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping);
+
+    Collection<OperationFieldMappingRow> getOperationFieldMapping();
+
+    void setOperationFieldMapping(Collection<OperationFieldMappingRow> operationFieldMapping);
+
+    Zone getZone(int index);
+
+    boolean isZoneEmpty();
+
+    int sizeZone();
+
+    void addZone(Zone zone);
+
+    void addAllZone(Collection<Zone> zone);
+
+    boolean removeZone(Zone zone);
+
+    boolean removeAllZone(Collection<Zone> zone);
+
+    boolean containsZone(Zone zone);
+
+    boolean containsAllZone(Collection<Zone> zone);
+
+    Collection<Zone> getZone();
+
+    void setZone(Collection<Zone> zone);
+
+} //TuttiProtocol
diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocolBean3.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocolBean3.java
new file mode 100644
index 0000000..8bdeee0
--- /dev/null
+++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v3/TuttiProtocolBean3.java
@@ -0,0 +1,598 @@
+package fr.ifremer.tutti.persistence.entities.protocol.v3;
+
+import fr.ifremer.tutti.persistence.entities.TuttiEntityBean;
+import fr.ifremer.tutti.persistence.entities.protocol.CaracteristicMappingRow;
+import fr.ifremer.tutti.persistence.entities.protocol.OperationFieldMappingRow;
+import fr.ifremer.tutti.persistence.entities.protocol.Zone;
+
+import javax.annotation.Generated;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+
+@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Wed Feb 24 14:48:37 CET 2016")
+public class TuttiProtocolBean3 extends TuttiEntityBean implements TuttiProtocol3 {
+
+    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<SpeciesProtocol3> species;
+
+    protected List<SpeciesProtocol3> benthos;
+
+    protected List<CaracteristicMappingRow> caracteristicMapping;
+
+    protected Collection<OperationFieldMappingRow> operationFieldMapping;
+
+    protected Collection<Zone> zone;
+
+    @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 SpeciesProtocol3 getSpecies(int index) {
+        SpeciesProtocol3 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(SpeciesProtocol3 species) {
+        getSpecies().add(species);
+    }
+
+    @Override
+    public void addAllSpecies(Collection<SpeciesProtocol3> species) {
+        getSpecies().addAll(species);
+    }
+
+    @Override
+    public boolean removeSpecies(SpeciesProtocol3 species) {
+        boolean removed = getSpecies().remove(species);
+        return removed;
+    }
+
+    @Override
+    public boolean removeAllSpecies(Collection<SpeciesProtocol3> species) {
+        boolean  removed = getSpecies().removeAll(species);
+        return removed;
+    }
+
+    @Override
+    public boolean containsSpecies(SpeciesProtocol3 species) {
+        boolean contains = getSpecies().contains(species);
+        return contains;
+    }
+
+    @Override
+    public boolean containsAllSpecies(Collection<SpeciesProtocol3> species) {
+        boolean  contains = getSpecies().containsAll(species);
+        return contains;
+    }
+
+    @Override
+    public List<SpeciesProtocol3> getSpecies() {
+    if (species == null) {
+        species = new LinkedList<SpeciesProtocol3>();
+    }
+    return species;
+}
+
+    @Override
+    public void setSpecies(List<SpeciesProtocol3> species) {
+        this.species = species;
+    }
+
+    @Override
+    public SpeciesProtocol3 getBenthos(int index) {
+        SpeciesProtocol3 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(SpeciesProtocol3 benthos) {
+        getBenthos().add(benthos);
+    }
+
+    @Override
+    public void addAllBenthos(Collection<SpeciesProtocol3> benthos) {
+        getBenthos().addAll(benthos);
+    }
+
+    @Override
+    public boolean removeBenthos(SpeciesProtocol3 benthos) {
+        boolean removed = getBenthos().remove(benthos);
+        return removed;
+    }
+
+    @Override
+    public boolean removeAllBenthos(Collection<SpeciesProtocol3> benthos) {
+        boolean  removed = getBenthos().removeAll(benthos);
+        return removed;
+    }
+
+    @Override
+    public boolean containsBenthos(SpeciesProtocol3 benthos) {
+        boolean contains = getBenthos().contains(benthos);
+        return contains;
+    }
+
+    @Override
+    public boolean containsAllBenthos(Collection<SpeciesProtocol3> benthos) {
+        boolean  contains = getBenthos().containsAll(benthos);
+        return contains;
+    }
+
+    @Override
+    public List<SpeciesProtocol3> getBenthos() {
+    if (benthos == null) {
+        benthos = new LinkedList<SpeciesProtocol3>();
+    }
+    return benthos;
+}
+
+    @Override
+    public void setBenthos(List<SpeciesProtocol3> 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;
+    }
+
+} //AbstractTuttiProtocolBean

-- 
To stop receiving notification emails like this one, please contact
codelutin.com SCM administrator <admin+scm@codelutin.com>.

    

[Tutti-commits] 05/11: migration du protocole (refs #8013)

codelutin.com scm