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

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>.