001// license-header java merge-point
002//
003// Attention: Generated code! Do not modify by hand!
004// Generated by: hibernate/HibernateEntity.vsl in andromda-hibernate-cartridge.
005//
006package fr.ifremer.adagio.core.dao.referential.taxon;
007
008/*
009 * #%L
010 * SIH-Adagio :: Core
011 * $Id:$
012 * $HeadURL:$
013 * %%
014 * Copyright (C) 2012 - 2014 Ifremer
015 * %%
016 * This program is free software: you can redistribute it and/or modify
017 * it under the terms of the GNU Affero General Public License as published by
018 * the Free Software Foundation, either version 3 of the License, or
019 * (at your option) any later version.
020 * 
021 * This program is distributed in the hope that it will be useful,
022 * but WITHOUT ANY WARRANTY; without even the implied warranty of
023 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
024 * GNU General Public License for more details.
025 * 
026 * You should have received a copy of the GNU Affero General Public License
027 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
028 * #L%
029 */
030
031import fr.ifremer.adagio.core.dao.referential.Status;
032import fr.ifremer.adagio.core.dao.referential.ValidityStatus;
033import java.io.Serializable;
034import java.sql.Timestamp;
035import java.util.Collection;
036import java.util.Date;
037import java.util.HashSet;
038
039/**
040 * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant les
041 * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par exemple
042 * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
043 * trophiques ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
044 * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
045 * benthiques). Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement
046 * appelé groupe de taxons père.
047 * Les groupes de taxons sont de deux catégories :
048 * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements de
049 * taxons sont effectués en aval de la mesure effectuée.
050 * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de taxons
051 * sur le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
052 * lorsque celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
053 * s'effectue alors en amont de la mesure.
054 * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour toute
055 * dans un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
056 * jour, et encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit
057 * pas être une règle générale)
058 */
059// HibernateEntity.vsl annotations merge-point
060public abstract class TaxonGroup
061    implements Serializable, Comparable<TaxonGroup>
062{
063    /**
064     * The serial version UID of this class. Needed for serialization.
065     */
066    private static final long serialVersionUID = -8545358162349439616L;
067
068    // Generate 8 attributes
069    private Integer id;
070
071    /**
072     * Identifiant unique du groupe de taxons.
073     * @return this.id Integer
074     */
075    public Integer getId()
076    {
077        return this.id;
078    }
079
080    /**
081     * Identifiant unique du groupe de taxons.
082     * @param idIn Integer
083     */
084    public void setId(Integer idIn)
085    {
086        this.id = idIn;
087    }
088
089    private String label;
090
091    /**
092     * Code (ou mnénomique) du groupe de taxons. Ceci peut être un code de quelques caractères
093     * identifiant le groupe. (exemple: Ca pour carnivores)
094     * @return this.label String
095     */
096    public String getLabel()
097    {
098        return this.label;
099    }
100
101    /**
102     * Code (ou mnénomique) du groupe de taxons. Ceci peut être un code de quelques caractères
103     * identifiant le groupe. (exemple: Ca pour carnivores)
104     * @param labelIn String
105     */
106    public void setLabel(String labelIn)
107    {
108        this.label = labelIn;
109    }
110
111    private String name;
112
113    /**
114     * Nom du groupe de taxons.
115     * @return this.name String
116     */
117    public String getName()
118    {
119        return this.name;
120    }
121
122    /**
123     * Nom du groupe de taxons.
124     * @param nameIn String
125     */
126    public void setName(String nameIn)
127    {
128        this.name = nameIn;
129    }
130
131    private String comments;
132
133    /**
134     * Commentaire long associé au groupe de taxons.
135     * @return this.comments String
136     */
137    public String getComments()
138    {
139        return this.comments;
140    }
141
142    /**
143     * Commentaire long associé au groupe de taxons.
144     * @param commentsIn String
145     */
146    public void setComments(String commentsIn)
147    {
148        this.comments = commentsIn;
149    }
150
151    private Boolean isChildGroupExclusive;
152
153    /**
154     * Ce champ permet de renseigner si les groupes de taxons fils sont exclusifs ou pas. Par
155     * défaut, les fils ne sont pas exclusifs. S'ils sont exclusifs, un même taxon ne pourra pas
156     * faire parti de plusieurs groupes du même taxon père.
157     * @return this.isChildGroupExclusive Boolean
158     */
159    public Boolean isIsChildGroupExclusive()
160    {
161        return this.isChildGroupExclusive;
162    }
163
164    /**
165     * Ce champ permet de renseigner si les groupes de taxons fils sont exclusifs ou pas. Par
166     * défaut, les fils ne sont pas exclusifs. S'ils sont exclusifs, un même taxon ne pourra pas
167     * faire parti de plusieurs groupes du même taxon père.
168     * @param isChildGroupExclusiveIn Boolean
169     */
170    public void setIsChildGroupExclusive(Boolean isChildGroupExclusiveIn)
171    {
172        this.isChildGroupExclusive = isChildGroupExclusiveIn;
173    }
174
175    private Boolean isUpdatable;
176
177    /**
178     * Cette information permet de savoir si un groupe de taxons est modifiable ou pas dans
179     * l'interface de mise à jour.
180     * @return this.isUpdatable Boolean
181     */
182    public Boolean isIsUpdatable()
183    {
184        return this.isUpdatable;
185    }
186
187    /**
188     * Cette information permet de savoir si un groupe de taxons est modifiable ou pas dans
189     * l'interface de mise à jour.
190     * @param isUpdatableIn Boolean
191     */
192    public void setIsUpdatable(Boolean isUpdatableIn)
193    {
194        this.isUpdatable = isUpdatableIn;
195    }
196
197    private Date creationDate;
198
199    /**
200     * Date de création système du groupe. Renseigné automatiquement par le système.
201     * @return this.creationDate Date
202     */
203    public Date getCreationDate()
204    {
205        return this.creationDate;
206    }
207
208    /**
209     * Date de création système du groupe. Renseigné automatiquement par le système.
210     * @param creationDateIn Date
211     */
212    public void setCreationDate(Date creationDateIn)
213    {
214        this.creationDate = creationDateIn;
215    }
216
217    private Timestamp updateDate;
218
219    /**
220     * Date de mise à jour système du groupe. Renseigné automatiquement par le système.
221     * @return this.updateDate Timestamp
222     */
223    public Timestamp getUpdateDate()
224    {
225        return this.updateDate;
226    }
227
228    /**
229     * Date de mise à jour système du groupe. Renseigné automatiquement par le système.
230     * @param updateDateIn Timestamp
231     */
232    public void setUpdateDate(Timestamp updateDateIn)
233    {
234        this.updateDate = updateDateIn;
235    }
236
237    // Generate 24 associations
238    private ValidityStatus validityStatus;
239
240    /**
241     * Etat de validation d'une donnée du référentiel. Utile pour les responsables de référentiel.
242     * Validity status of a referential data.
243     * @return this.validityStatus ValidityStatus
244     */
245    public ValidityStatus getValidityStatus()
246    {
247        return this.validityStatus;
248    }
249
250    /**
251     * Etat de validation d'une donnée du référentiel. Utile pour les responsables de référentiel.
252     * Validity status of a referential data.
253     * @param validityStatusIn ValidityStatus
254     */
255    public void setValidityStatus(ValidityStatus validityStatusIn)
256    {
257        this.validityStatus = validityStatusIn;
258    }
259
260    private TaxonGroup parentTaxonGroup;
261
262    /**
263     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
264     * les
265     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
266     * exemple
267     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
268     * trophiques
269     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
270     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
271     * benthiques).
272     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
273     * groupe de
274     * taxons père.
275     * Les groupes de taxons sont de deux catégories :
276     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
277     * de
278     * taxons sont effectués en aval de la mesure effectuée.
279     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
280     * taxons sur
281     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
282     * lorsque
283     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
284     * s'effectue
285     * alors en amont de la mesure.
286     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
287     * toute dans
288     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
289     * jour, et
290     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
291     * être une
292     * règle générale)
293     * @return this.parentTaxonGroup TaxonGroup
294     */
295    public TaxonGroup getParentTaxonGroup()
296    {
297        return this.parentTaxonGroup;
298    }
299
300    /**
301     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
302     * les
303     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
304     * exemple
305     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
306     * trophiques
307     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
308     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
309     * benthiques).
310     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
311     * groupe de
312     * taxons père.
313     * Les groupes de taxons sont de deux catégories :
314     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
315     * de
316     * taxons sont effectués en aval de la mesure effectuée.
317     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
318     * taxons sur
319     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
320     * lorsque
321     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
322     * s'effectue
323     * alors en amont de la mesure.
324     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
325     * toute dans
326     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
327     * jour, et
328     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
329     * être une
330     * règle générale)
331     * @param parentTaxonGroupIn TaxonGroup
332     */
333    public void setParentTaxonGroup(TaxonGroup parentTaxonGroupIn)
334    {
335        this.parentTaxonGroup = parentTaxonGroupIn;
336    }
337
338    private Collection<TaxonGroup> childTaxonGroups = new HashSet<TaxonGroup>();
339
340    /**
341     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
342     * les
343     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
344     * exemple
345     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
346     * trophiques
347     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
348     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
349     * benthiques).
350     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
351     * groupe de
352     * taxons père.
353     * Les groupes de taxons sont de deux catégories :
354     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
355     * de
356     * taxons sont effectués en aval de la mesure effectuée.
357     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
358     * taxons sur
359     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
360     * lorsque
361     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
362     * s'effectue
363     * alors en amont de la mesure.
364     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
365     * toute dans
366     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
367     * jour, et
368     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
369     * être une
370     * règle générale)
371     * @return this.childTaxonGroups Collection<TaxonGroup>
372     */
373    public Collection<TaxonGroup> getChildTaxonGroups()
374    {
375        return this.childTaxonGroups;
376    }
377
378    /**
379     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
380     * les
381     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
382     * exemple
383     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
384     * trophiques
385     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
386     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
387     * benthiques).
388     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
389     * groupe de
390     * taxons père.
391     * Les groupes de taxons sont de deux catégories :
392     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
393     * de
394     * taxons sont effectués en aval de la mesure effectuée.
395     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
396     * taxons sur
397     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
398     * lorsque
399     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
400     * s'effectue
401     * alors en amont de la mesure.
402     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
403     * toute dans
404     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
405     * jour, et
406     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
407     * être une
408     * règle générale)
409     * @param childTaxonGroupsIn Collection<TaxonGroup>
410     */
411    public void setChildTaxonGroups(Collection<TaxonGroup> childTaxonGroupsIn)
412    {
413        this.childTaxonGroups = childTaxonGroupsIn;
414    }
415
416    /**
417     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
418     * les
419     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
420     * exemple
421     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
422     * trophiques
423     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
424     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
425     * benthiques).
426     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
427     * groupe de
428     * taxons père.
429     * Les groupes de taxons sont de deux catégories :
430     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
431     * de
432     * taxons sont effectués en aval de la mesure effectuée.
433     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
434     * taxons sur
435     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
436     * lorsque
437     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
438     * s'effectue
439     * alors en amont de la mesure.
440     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
441     * toute dans
442     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
443     * jour, et
444     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
445     * être une
446     * règle générale)
447     * @param elementToAdd TaxonGroup
448     * @return <tt>true</tt> if this collection changed as a result of the
449     *         call
450     */
451    public boolean addChildTaxonGroups(TaxonGroup elementToAdd)
452    {
453        return this.childTaxonGroups.add(elementToAdd);
454    }
455
456    /**
457     * Il désigne un ensemble de taxons appartenant à des groupes taxinomiques différents mais ayant
458     * les
459     * mêmes caractéristiques pour un critère donné. Ce critère peut être morpho-anatomique (par
460     * exemple
461     * les strates algales ou la taille des organismes), comportemental (par exemple des groupes
462     * trophiques
463     * ou des modes de déplacement), ou encore basé sur des notions plus complexes comme la
464     * polluo-sensibilité (exemple des groupes écologiques définis pour les macroinvertébrés
465     * benthiques).
466     * Pour un critère donné, les groupes de taxons sont rassemblés dans un regroupement appelé
467     * groupe de
468     * taxons père.
469     * Les groupes de taxons sont de deux catégories :
470     * - Descriptif : c'est à dire seulement utilisé pour l'extraction de données. Les regroupements
471     * de
472     * taxons sont effectués en aval de la mesure effectuée.
473     * - Identification : il s'agit de regroupements utilisés pour identifier des catégories de
474     * taxons sur
475     * le terrain ou en laboratoire, lorsqu'il est difficile d'opérer une identification précise ou
476     * lorsque
477     * celle-ci s'avère tout simplement impossible ou non pertinente. Le regroupement des taxons
478     * s'effectue
479     * alors en amont de la mesure.
480     * Certains groupes peuvent être figés, c'est à dire qu'ils sont définis une bonne fois pour
481     * toute dans
482     * un document. Pour ce dernier cas particulier, il n'y a donc, a priori, pas besoin de mise à
483     * jour, et
484     * encore moins de pouvoir les supprimer : ils sont donc non modifiables (mais ce ne doit pas
485     * être une
486     * règle générale)
487     * @param elementToRemove TaxonGroup
488     * @return <tt>true</tt> if this collection changed as a result of the
489     *         call
490     */
491    public boolean removeChildTaxonGroups(TaxonGroup elementToRemove)
492    {
493        return this.childTaxonGroups.remove(elementToRemove);
494    }
495
496    private Collection<TaxonGroupInformation> taxonGroupInformations = new HashSet<TaxonGroupInformation>();
497
498    /**
499     * 
500     * @return this.taxonGroupInformations Collection<TaxonGroupInformation>
501     */
502    public Collection<TaxonGroupInformation> getTaxonGroupInformations()
503    {
504        return this.taxonGroupInformations;
505    }
506
507    /**
508     * 
509     * @param taxonGroupInformationsIn Collection<TaxonGroupInformation>
510     */
511    public void setTaxonGroupInformations(Collection<TaxonGroupInformation> taxonGroupInformationsIn)
512    {
513        this.taxonGroupInformations = taxonGroupInformationsIn;
514    }
515
516    /**
517     * 
518     * @param elementToAdd TaxonGroupInformation
519     * @return <tt>true</tt> if this collection changed as a result of the
520     *         call
521     */
522    public boolean addTaxonGroupInformations(TaxonGroupInformation elementToAdd)
523    {
524        return this.taxonGroupInformations.add(elementToAdd);
525    }
526
527    /**
528     * 
529     * @param elementToRemove TaxonGroupInformation
530     * @return <tt>true</tt> if this collection changed as a result of the
531     *         call
532     */
533    public boolean removeTaxonGroupInformations(TaxonGroupInformation elementToRemove)
534    {
535        return this.taxonGroupInformations.remove(elementToRemove);
536    }
537
538    private TaxonGroupType taxonGroupType;
539
540    /**
541     * Type de groupe de taxon.
542     * On distingue plusieurs types de regroupements de taxons :
543     * - les groupes descriptifs des taxons, et utilisés à l'extraction des données (groupes
544     * écologiques
545     * par exemple)
546     * - les groupes utilisés pour l'identification sur les navires de pêche ou dans les criées :
547     * espèce
548     * commerciale, ou espèce communes (nom vernaculaire)
549     * -  ...
550     * @return this.taxonGroupType TaxonGroupType
551     */
552    public TaxonGroupType getTaxonGroupType()
553    {
554        return this.taxonGroupType;
555    }
556
557    /**
558     * Type de groupe de taxon.
559     * On distingue plusieurs types de regroupements de taxons :
560     * - les groupes descriptifs des taxons, et utilisés à l'extraction des données (groupes
561     * écologiques
562     * par exemple)
563     * - les groupes utilisés pour l'identification sur les navires de pêche ou dans les criées :
564     * espèce
565     * commerciale, ou espèce communes (nom vernaculaire)
566     * -  ...
567     * @param taxonGroupTypeIn TaxonGroupType
568     */
569    public void setTaxonGroupType(TaxonGroupType taxonGroupTypeIn)
570    {
571        this.taxonGroupType = taxonGroupTypeIn;
572    }
573
574    private Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecords = new HashSet<TaxonGroupHistoricalRecord>();
575
576    /**
577     * Date de début d'appartenance du taxon au groupe. Cette date est renseignée automatiquemnt par
578     * le
579     * système.
580     * @return this.taxonGroupHistoricalRecords Collection<TaxonGroupHistoricalRecord>
581     */
582    public Collection<TaxonGroupHistoricalRecord> getTaxonGroupHistoricalRecords()
583    {
584        return this.taxonGroupHistoricalRecords;
585    }
586
587    /**
588     * Date de début d'appartenance du taxon au groupe. Cette date est renseignée automatiquemnt par
589     * le
590     * système.
591     * @param taxonGroupHistoricalRecordsIn Collection<TaxonGroupHistoricalRecord>
592     */
593    public void setTaxonGroupHistoricalRecords(Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecordsIn)
594    {
595        this.taxonGroupHistoricalRecords = taxonGroupHistoricalRecordsIn;
596    }
597
598    /**
599     * Date de début d'appartenance du taxon au groupe. Cette date est renseignée automatiquemnt par
600     * le
601     * système.
602     * @param elementToAdd TaxonGroupHistoricalRecord
603     * @return <tt>true</tt> if this collection changed as a result of the
604     *         call
605     */
606    public boolean addTaxonGroupHistoricalRecords(TaxonGroupHistoricalRecord elementToAdd)
607    {
608        return this.taxonGroupHistoricalRecords.add(elementToAdd);
609    }
610
611    /**
612     * Date de début d'appartenance du taxon au groupe. Cette date est renseignée automatiquemnt par
613     * le
614     * système.
615     * @param elementToRemove TaxonGroupHistoricalRecord
616     * @return <tt>true</tt> if this collection changed as a result of the
617     *         call
618     */
619    public boolean removeTaxonGroupHistoricalRecords(TaxonGroupHistoricalRecord elementToRemove)
620    {
621        return this.taxonGroupHistoricalRecords.remove(elementToRemove);
622    }
623
624    private Status status;
625
626    /**
627     * Pour les données du référentiel, information permettant de déterminer si une donnée est
628     * valide,
629     * obsolète ou temporaire.
630     * - obsolète (=inactif) : '0'
631     * - valide (=actif) : '1'
632     * - temporaire : '2'
633     * - en cours de suppression : '3'
634     * -  : '4'
635     * note : on a préfère ici 'valide' au terme 'actif' (utilisé dans Harmonie), pour ne pas
636     * confondre
637     * avec par exemple l'activité d'un navire sur un mois.
638     * @return this.status Status
639     */
640    public Status getStatus()
641    {
642        return this.status;
643    }
644
645    /**
646     * Pour les données du référentiel, information permettant de déterminer si une donnée est
647     * valide,
648     * obsolète ou temporaire.
649     * - obsolète (=inactif) : '0'
650     * - valide (=actif) : '1'
651     * - temporaire : '2'
652     * - en cours de suppression : '3'
653     * -  : '4'
654     * note : on a préfère ici 'valide' au terme 'actif' (utilisé dans Harmonie), pour ne pas
655     * confondre
656     * avec par exemple l'activité d'un navire sur un mois.
657     * @param statusIn Status
658     */
659    public void setStatus(Status statusIn)
660    {
661        this.status = statusIn;
662    }
663
664    /**
665     * Returns <code>true</code> if the argument is an TaxonGroup instance and all identifiers for this entity
666     * equal the identifiers of the argument entity. Returns <code>false</code> otherwise.
667     */
668    @Override
669    public boolean equals(Object object)
670    {
671        if (this == object)
672        {
673            return true;
674        }
675        if (!(object instanceof TaxonGroup))
676        {
677            return false;
678        }
679        final TaxonGroup that = (TaxonGroup)object;
680        if (this.id == null || that.getId() == null || !this.id.equals(that.getId()))
681        {
682            return false;
683        }
684        return true;
685    }
686
687    /**
688     * Returns a hash code based on this entity's identifiers.
689     */
690    @Override
691    public int hashCode()
692    {
693        int hashCode = 0;
694        hashCode = 29 * hashCode + (this.id == null ? 0 : this.id.hashCode());
695
696        return hashCode;
697    }
698
699    /**
700     * Constructs new instances of {@link TaxonGroup}.
701     */
702    public static final class Factory
703    {
704        /**
705         * Constructs a new instance of {@link TaxonGroup}.
706         * @return new TaxonGroupImpl()
707         */
708        public static TaxonGroup newInstance()
709        {
710            return new TaxonGroupImpl();
711        }
712
713        /**
714         * Constructs a new instance of {@link TaxonGroup}, taking all required and/or
715         * read-only properties as arguments, except for identifiers.
716         * @param name String
717         * @param isChildGroupExclusive Boolean
718         * @param isUpdatable Boolean
719         * @param creationDate Date
720         * @param updateDate Timestamp
721         * @param validityStatus ValidityStatus
722         * @param taxonGroupType TaxonGroupType
723         * @param status Status
724         * @return newInstance
725         */
726        public static TaxonGroup newInstance(String name, Boolean isChildGroupExclusive, Boolean isUpdatable, Date creationDate, Timestamp updateDate, ValidityStatus validityStatus, TaxonGroupType taxonGroupType, Status status)
727        {
728            final TaxonGroup entity = new TaxonGroupImpl();
729            entity.setName(name);
730            entity.setIsChildGroupExclusive(isChildGroupExclusive);
731            entity.setIsUpdatable(isUpdatable);
732            entity.setCreationDate(creationDate);
733            entity.setUpdateDate(updateDate);
734            entity.setValidityStatus(validityStatus);
735            entity.setTaxonGroupType(taxonGroupType);
736            entity.setStatus(status);
737            return entity;
738        }
739
740        /**
741         * Constructs a new instance of {@link TaxonGroup}, taking all possible properties
742         * (except the identifier(s))as arguments.
743         * @param label String
744         * @param name String
745         * @param comments String
746         * @param isChildGroupExclusive Boolean
747         * @param isUpdatable Boolean
748         * @param creationDate Date
749         * @param updateDate Timestamp
750         * @param validityStatus ValidityStatus
751         * @param parentTaxonGroup TaxonGroup
752         * @param childTaxonGroups Collection<TaxonGroup>
753         * @param taxonGroupInformations Collection<TaxonGroupInformation>
754         * @param taxonGroupType TaxonGroupType
755         * @param taxonGroupHistoricalRecords Collection<TaxonGroupHistoricalRecord>
756         * @param status Status
757         * @return newInstance TaxonGroup
758         */
759        public static TaxonGroup newInstance(String label, String name, String comments, Boolean isChildGroupExclusive, Boolean isUpdatable, Date creationDate, Timestamp updateDate, ValidityStatus validityStatus, TaxonGroup parentTaxonGroup, Collection<TaxonGroup> childTaxonGroups, Collection<TaxonGroupInformation> taxonGroupInformations, TaxonGroupType taxonGroupType, Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecords, Status status)
760        {
761            final TaxonGroup entity = new TaxonGroupImpl();
762            entity.setLabel(label);
763            entity.setName(name);
764            entity.setComments(comments);
765            entity.setIsChildGroupExclusive(isChildGroupExclusive);
766            entity.setIsUpdatable(isUpdatable);
767            entity.setCreationDate(creationDate);
768            entity.setUpdateDate(updateDate);
769            entity.setValidityStatus(validityStatus);
770            entity.setParentTaxonGroup(parentTaxonGroup);
771            entity.setChildTaxonGroups(childTaxonGroups);
772            entity.setTaxonGroupInformations(taxonGroupInformations);
773            entity.setTaxonGroupType(taxonGroupType);
774            entity.setTaxonGroupHistoricalRecords(taxonGroupHistoricalRecords);
775            entity.setStatus(status);
776            return entity;
777        }
778    }
779
780    /**
781     * @see Comparable#compareTo
782     */
783    public int compareTo(TaxonGroup o)
784    {
785        int cmp = 0;
786        if (this.getId() != null)
787        {
788            cmp = this.getId().compareTo(o.getId());
789        }
790        else
791        {
792            if (this.getLabel() != null)
793            {
794                cmp = (cmp != 0 ? cmp : this.getLabel().compareTo(o.getLabel()));
795            }
796            if (this.getName() != null)
797            {
798                cmp = (cmp != 0 ? cmp : this.getName().compareTo(o.getName()));
799            }
800            if (this.getComments() != null)
801            {
802                cmp = (cmp != 0 ? cmp : this.getComments().compareTo(o.getComments()));
803            }
804            if (this.isIsChildGroupExclusive() != null)
805            {
806                cmp = (cmp != 0 ? cmp : this.isIsChildGroupExclusive().compareTo(o.isIsChildGroupExclusive()));
807            }
808            if (this.isIsUpdatable() != null)
809            {
810                cmp = (cmp != 0 ? cmp : this.isIsUpdatable().compareTo(o.isIsUpdatable()));
811            }
812            if (this.getCreationDate() != null)
813            {
814                cmp = (cmp != 0 ? cmp : this.getCreationDate().compareTo(o.getCreationDate()));
815            }
816            if (this.getUpdateDate() != null)
817            {
818                cmp = (cmp != 0 ? cmp : this.getUpdateDate().compareTo(o.getUpdateDate()));
819            }
820        }
821        return cmp;
822    }
823// HibernateEntity.vsl merge-point
824// TaxonGroup.java merge-point
825}