This is an automated email from the git hooks/post-receive script. New commit to branch develop in repository tutti. See http://git.codelutin.com/tutti.git commit b1b82c0687e79fb76051b09a9a849041c0515ca4 Author: Kevin Morin <morin@codelutin.com> Date: Mon Nov 24 14:31:13 2014 +0100 refs #5954 add v2 version --- .../entities/protocol/v2/TuttiProtocol2.java | 176 ++++++++ .../entities/protocol/v2/TuttiProtocolBean2.java | 444 +++++++++++++++++++++ 2 files changed, 620 insertions(+) diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocol2.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocol2.java new file mode 100644 index 0000000..a67f592 --- /dev/null +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocol2.java @@ -0,0 +1,176 @@ +package fr.ifremer.tutti.persistence.entities.protocol.v2; + +import fr.ifremer.tutti.persistence.entities.CommentAware; +import fr.ifremer.tutti.persistence.entities.TuttiEntity; +import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; + +import javax.annotation.Generated; +import java.util.Collection; +import java.util.List; + +@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Mon Nov 24 12:54:48 CET 2014") +public interface TuttiProtocol2 extends CommentAware, TuttiEntity { + + String PROPERTY_NAME = "name"; + + String PROPERTY_COMMENT = "comment"; + + String PROPERTY_GEAR_USE_FEATURE_PMFM_ID = "gearUseFeaturePmfmId"; + + String PROPERTY_VESSEL_USE_FEATURE_PMFM_ID = "vesselUseFeaturePmfmId"; + + String PROPERTY_LENGTH_CLASSES_PMFM_ID = "lengthClassesPmfmId"; + + String PROPERTY_INDIVIDUAL_OBSERVATION_PMFM_ID = "individualObservationPmfmId"; + + String PROPERTY_VERSION = "version"; + + String PROPERTY_SPECIES = "species"; + + String PROPERTY_BENTHOS = "benthos"; + + String getName(); + + void setName(String name); + + String getComment(); + + void setComment(String comment); + + String getGearUseFeaturePmfmId(int index); + + boolean isGearUseFeaturePmfmIdEmpty(); + + int sizeGearUseFeaturePmfmId(); + + void addGearUseFeaturePmfmId(String gearUseFeaturePmfmId); + + void addAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId); + + boolean removeGearUseFeaturePmfmId(String gearUseFeaturePmfmId); + + boolean removeAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId); + + boolean containsGearUseFeaturePmfmId(String gearUseFeaturePmfmId); + + boolean containsAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId); + + List<String> getGearUseFeaturePmfmId(); + + void setGearUseFeaturePmfmId(List<String> gearUseFeaturePmfmId); + + String getVesselUseFeaturePmfmId(int index); + + boolean isVesselUseFeaturePmfmIdEmpty(); + + int sizeVesselUseFeaturePmfmId(); + + void addVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId); + + void addAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId); + + boolean removeVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId); + + boolean removeAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId); + + boolean containsVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId); + + boolean containsAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId); + + List<String> getVesselUseFeaturePmfmId(); + + void setVesselUseFeaturePmfmId(List<String> vesselUseFeaturePmfmId); + + 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); + + SpeciesProtocol getSpecies(int index); + + boolean isSpeciesEmpty(); + + int sizeSpecies(); + + void addSpecies(SpeciesProtocol species); + + void addAllSpecies(Collection<SpeciesProtocol> species); + + boolean removeSpecies(SpeciesProtocol species); + + boolean removeAllSpecies(Collection<SpeciesProtocol> species); + + boolean containsSpecies(SpeciesProtocol species); + + boolean containsAllSpecies(Collection<SpeciesProtocol> species); + + List<SpeciesProtocol> getSpecies(); + + void setSpecies(List<SpeciesProtocol> species); + + SpeciesProtocol getBenthos(int index); + + boolean isBenthosEmpty(); + + int sizeBenthos(); + + void addBenthos(SpeciesProtocol benthos); + + void addAllBenthos(Collection<SpeciesProtocol> benthos); + + boolean removeBenthos(SpeciesProtocol benthos); + + boolean removeAllBenthos(Collection<SpeciesProtocol> benthos); + + boolean containsBenthos(SpeciesProtocol benthos); + + boolean containsAllBenthos(Collection<SpeciesProtocol> benthos); + + List<SpeciesProtocol> getBenthos(); + + void setBenthos(List<SpeciesProtocol> benthos); + +} //TuttiProtocol diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocolBean2.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocolBean2.java new file mode 100644 index 0000000..9ae21f3 --- /dev/null +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/entities/protocol/v2/TuttiProtocolBean2.java @@ -0,0 +1,444 @@ +package fr.ifremer.tutti.persistence.entities.protocol.v2; + +import fr.ifremer.tutti.persistence.entities.TuttiEntityBean; +import fr.ifremer.tutti.persistence.entities.protocol.AbstractTuttiProtocolBean; +import fr.ifremer.tutti.persistence.entities.protocol.SpeciesProtocol; +import fr.ifremer.tutti.persistence.entities.protocol.TuttiProtocol; + +import javax.annotation.Generated; +import java.util.Collection; +import java.util.LinkedList; +import java.util.List; + +@Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Mon Nov 24 12:54:48 CET 2014") +public class TuttiProtocolBean2 extends TuttiEntityBean implements TuttiProtocol { + + private static final long serialVersionUID = 3847260679792845110L; + + protected String name; + + protected String comment; + + protected List<String> gearUseFeaturePmfmId; + + protected List<String> vesselUseFeaturePmfmId; + + protected List<String> lengthClassesPmfmId; + + protected List<String> individualObservationPmfmId; + + protected Integer version; + + protected List<SpeciesProtocol> species; + + protected List<SpeciesProtocol> benthos; + + @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 getGearUseFeaturePmfmId(int index) { + String o = getChild(gearUseFeaturePmfmId, index); + return o; + } + + @Override + public boolean isGearUseFeaturePmfmIdEmpty() { + return gearUseFeaturePmfmId == null || gearUseFeaturePmfmId.isEmpty(); + } + + @Override + public int sizeGearUseFeaturePmfmId() { + return gearUseFeaturePmfmId == null ? 0 : gearUseFeaturePmfmId.size(); + } + + @Override + public void addGearUseFeaturePmfmId(String gearUseFeaturePmfmId) { + getGearUseFeaturePmfmId().add(gearUseFeaturePmfmId); + } + + @Override + public void addAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId) { + getGearUseFeaturePmfmId().addAll(gearUseFeaturePmfmId); + } + + @Override + public boolean removeGearUseFeaturePmfmId(String gearUseFeaturePmfmId) { + boolean removed = getGearUseFeaturePmfmId().remove(gearUseFeaturePmfmId); + return removed; + } + + @Override + public boolean removeAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId) { + boolean removed = getGearUseFeaturePmfmId().removeAll(gearUseFeaturePmfmId); + return removed; + } + + @Override + public boolean containsGearUseFeaturePmfmId(String gearUseFeaturePmfmId) { + boolean contains = getGearUseFeaturePmfmId().contains(gearUseFeaturePmfmId); + return contains; + } + + @Override + public boolean containsAllGearUseFeaturePmfmId(Collection<String> gearUseFeaturePmfmId) { + boolean contains = getGearUseFeaturePmfmId().containsAll(gearUseFeaturePmfmId); + return contains; + } + + @Override + public List<String> getGearUseFeaturePmfmId() { + if (gearUseFeaturePmfmId == null) { + gearUseFeaturePmfmId = new LinkedList<String>(); + } + return gearUseFeaturePmfmId; + } + + @Override + public void setGearUseFeaturePmfmId(List<String> gearUseFeaturePmfmId) { + this.gearUseFeaturePmfmId = gearUseFeaturePmfmId; + } + + @Override + public String getVesselUseFeaturePmfmId(int index) { + String o = getChild(vesselUseFeaturePmfmId, index); + return o; + } + + @Override + public boolean isVesselUseFeaturePmfmIdEmpty() { + return vesselUseFeaturePmfmId == null || vesselUseFeaturePmfmId.isEmpty(); + } + + @Override + public int sizeVesselUseFeaturePmfmId() { + return vesselUseFeaturePmfmId == null ? 0 : vesselUseFeaturePmfmId.size(); + } + + @Override + public void addVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId) { + getVesselUseFeaturePmfmId().add(vesselUseFeaturePmfmId); + } + + @Override + public void addAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId) { + getVesselUseFeaturePmfmId().addAll(vesselUseFeaturePmfmId); + } + + @Override + public boolean removeVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId) { + boolean removed = getVesselUseFeaturePmfmId().remove(vesselUseFeaturePmfmId); + return removed; + } + + @Override + public boolean removeAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId) { + boolean removed = getVesselUseFeaturePmfmId().removeAll(vesselUseFeaturePmfmId); + return removed; + } + + @Override + public boolean containsVesselUseFeaturePmfmId(String vesselUseFeaturePmfmId) { + boolean contains = getVesselUseFeaturePmfmId().contains(vesselUseFeaturePmfmId); + return contains; + } + + @Override + public boolean containsAllVesselUseFeaturePmfmId(Collection<String> vesselUseFeaturePmfmId) { + boolean contains = getVesselUseFeaturePmfmId().containsAll(vesselUseFeaturePmfmId); + return contains; + } + + @Override + public List<String> getVesselUseFeaturePmfmId() { + if (vesselUseFeaturePmfmId == null) { + vesselUseFeaturePmfmId = new LinkedList<String>(); + } + return vesselUseFeaturePmfmId; + } + + @Override + public void setVesselUseFeaturePmfmId(List<String> vesselUseFeaturePmfmId) { + this.vesselUseFeaturePmfmId = vesselUseFeaturePmfmId; + } + + @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 SpeciesProtocol getSpecies(int index) { + SpeciesProtocol o = getChild(species, index); + return o; + } + + @Override + public boolean isSpeciesEmpty() { + return species == null || species.isEmpty(); + } + + @Override + public int sizeSpecies() { + return species == null ? 0 : species.size(); + } + + @Override + public void addSpecies(SpeciesProtocol species) { + getSpecies().add(species); + } + + @Override + public void addAllSpecies(Collection<SpeciesProtocol> species) { + getSpecies().addAll(species); + } + + @Override + public boolean removeSpecies(SpeciesProtocol species) { + boolean removed = getSpecies().remove(species); + return removed; + } + + @Override + public boolean removeAllSpecies(Collection<SpeciesProtocol> species) { + boolean removed = getSpecies().removeAll(species); + return removed; + } + + @Override + public boolean containsSpecies(SpeciesProtocol species) { + boolean contains = getSpecies().contains(species); + return contains; + } + + @Override + public boolean containsAllSpecies(Collection<SpeciesProtocol> species) { + boolean contains = getSpecies().containsAll(species); + return contains; + } + + @Override + public List<SpeciesProtocol> getSpecies() { + if (species == null) { + species = new LinkedList<SpeciesProtocol>(); + } + return species; + } + + @Override + public void setSpecies(List<SpeciesProtocol> species) { + this.species = species; + } + + @Override + public SpeciesProtocol getBenthos(int index) { + SpeciesProtocol o = getChild(benthos, index); + return o; + } + + @Override + public boolean isBenthosEmpty() { + return benthos == null || benthos.isEmpty(); + } + + @Override + public int sizeBenthos() { + return benthos == null ? 0 : benthos.size(); + } + + @Override + public void addBenthos(SpeciesProtocol benthos) { + getBenthos().add(benthos); + } + + @Override + public void addAllBenthos(Collection<SpeciesProtocol> benthos) { + getBenthos().addAll(benthos); + } + + @Override + public boolean removeBenthos(SpeciesProtocol benthos) { + boolean removed = getBenthos().remove(benthos); + return removed; + } + + @Override + public boolean removeAllBenthos(Collection<SpeciesProtocol> benthos) { + boolean removed = getBenthos().removeAll(benthos); + return removed; + } + + @Override + public boolean containsBenthos(SpeciesProtocol benthos) { + boolean contains = getBenthos().contains(benthos); + return contains; + } + + @Override + public boolean containsAllBenthos(Collection<SpeciesProtocol> benthos) { + boolean contains = getBenthos().containsAll(benthos); + return contains; + } + + @Override + public List<SpeciesProtocol> getBenthos() { + if (benthos == null) { + benthos = new LinkedList<SpeciesProtocol>(); + } + return benthos; + } + + @Override + public void setBenthos(List<SpeciesProtocol> benthos) { + this.benthos = benthos; + } + +} -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.