1 // license-header java merge-point
2 //
3 // Attention: Generated code! Do not modify by hand!
4 // Generated by: hibernate/HibernateEntity.vsl in andromda-hibernate-cartridge.
5 //
6 package fr.ifremer.quadrige2.core.dao.referential.taxon;
7
8 /*-
9 * #%L
10 * Quadrige2 Core :: Server API
11 * %%
12 * Copyright (C) 2017 Ifremer
13 * %%
14 * This program is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Affero General Public License as published by
16 * the Free Software Foundation, either version 3 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU Affero General Public License
25 * along with this program. If not, see <http://www.gnu.org/licenses/>.
26 * #L%
27 */
28
29 import java.io.Serializable;
30 import java.sql.Timestamp;
31 import java.util.Collection;
32 import java.util.Date;
33 import java.util.HashSet;
34
35 /**
36 * Liste les taxons (interface avec ERMS)
37 */
38 // HibernateEntity.vsl annotations merge-point
39 public abstract class TaxonName
40 implements Serializable, Comparable<TaxonName>
41 {
42 /**
43 * The serial version UID of this class. Needed for serialization.
44 */
45 private static final long serialVersionUID = -2916293180423349086L;
46
47 // Generate 14 attributes
48 private Integer taxonNameId;
49
50 /**
51 * Identifiant interne du taxon
52 * @return this.taxonNameId Integer
53 */
54 public Integer getTaxonNameId()
55 {
56 return this.taxonNameId;
57 }
58
59 /**
60 * Identifiant interne du taxon
61 * @param taxonNameIdIn Integer
62 */
63 public void setTaxonNameId(Integer taxonNameIdIn)
64 {
65 this.taxonNameId = taxonNameIdIn;
66 }
67
68 private String taxonNameNm;
69
70 /**
71 * Nom scientifique du taxon, unique pour le niveau
72 * @return this.taxonNameNm String
73 */
74 public String getTaxonNameNm()
75 {
76 return this.taxonNameNm;
77 }
78
79 /**
80 * Nom scientifique du taxon, unique pour le niveau
81 * @param taxonNameNmIn String
82 */
83 public void setTaxonNameNm(String taxonNameNmIn)
84 {
85 this.taxonNameNm = taxonNameNmIn;
86 }
87
88 private String taxonNameCompleteNm;
89
90 /**
91 * Nom concaténé du taxon
92 * @return this.taxonNameCompleteNm String
93 */
94 public String getTaxonNameCompleteNm()
95 {
96 return this.taxonNameCompleteNm;
97 }
98
99 /**
100 * Nom concaténé du taxon
101 * @param taxonNameCompleteNmIn String
102 */
103 public void setTaxonNameCompleteNm(String taxonNameCompleteNmIn)
104 {
105 this.taxonNameCompleteNm = taxonNameCompleteNmIn;
106 }
107
108 private Boolean taxonNameIsNaming;
109
110 /**
111 * Indique si le taxon respecte les règles de nommage
112 * @return this.taxonNameIsNaming Boolean
113 */
114 public Boolean getTaxonNameIsNaming()
115 {
116 return this.taxonNameIsNaming;
117 }
118
119 /**
120 * Indique si le taxon respecte les règles de nommage
121 * @param taxonNameIsNamingIn Boolean
122 */
123 public void setTaxonNameIsNaming(Boolean taxonNameIsNamingIn)
124 {
125 this.taxonNameIsNaming = taxonNameIsNamingIn;
126 }
127
128 private String taxonNameCm;
129
130 /**
131 * Commentaire sur le taxon
132 * @return this.taxonNameCm String
133 */
134 public String getTaxonNameCm()
135 {
136 return this.taxonNameCm;
137 }
138
139 /**
140 * Commentaire sur le taxon
141 * @param taxonNameCmIn String
142 */
143 public void setTaxonNameCm(String taxonNameCmIn)
144 {
145 this.taxonNameCm = taxonNameCmIn;
146 }
147
148 private Integer taxonNameUpperRk;
149
150 /**
151 * Rang du taxon parmis les fils d'un même père pour classement
152 * @return this.taxonNameUpperRk Integer
153 */
154 public Integer getTaxonNameUpperRk()
155 {
156 return this.taxonNameUpperRk;
157 }
158
159 /**
160 * Rang du taxon parmis les fils d'un même père pour classement
161 * @param taxonNameUpperRkIn Integer
162 */
163 public void setTaxonNameUpperRk(Integer taxonNameUpperRkIn)
164 {
165 this.taxonNameUpperRk = taxonNameUpperRkIn;
166 }
167
168 private Boolean taxonNameIsRefer;
169
170 /**
171 * Vrai si le taxon est le taxon référent, faux pour les synonymes.
172 * @return this.taxonNameIsRefer Boolean
173 */
174 public Boolean getTaxonNameIsRefer()
175 {
176 return this.taxonNameIsRefer;
177 }
178
179 /**
180 * Vrai si le taxon est le taxon référent, faux pour les synonymes.
181 * @param taxonNameIsReferIn Boolean
182 */
183 public void setTaxonNameIsRefer(Boolean taxonNameIsReferIn)
184 {
185 this.taxonNameIsRefer = taxonNameIsReferIn;
186 }
187
188 private Boolean taxonNameIsVirtual;
189
190 /**
191 * Indique si le taxon est virtuel ou non
192 * @return this.taxonNameIsVirtual Boolean
193 */
194 public Boolean getTaxonNameIsVirtual()
195 {
196 return this.taxonNameIsVirtual;
197 }
198
199 /**
200 * Indique si le taxon est virtuel ou non
201 * @param taxonNameIsVirtualIn Boolean
202 */
203 public void setTaxonNameIsVirtual(Boolean taxonNameIsVirtualIn)
204 {
205 this.taxonNameIsVirtual = taxonNameIsVirtualIn;
206 }
207
208 private Boolean taxonNameObsol;
209
210 /**
211 * Vrai si le taxon est devenu obsolète, il doit plus être proposé dans les listes de saisie
212 * @return this.taxonNameObsol Boolean
213 */
214 public Boolean getTaxonNameObsol()
215 {
216 return this.taxonNameObsol;
217 }
218
219 /**
220 * Vrai si le taxon est devenu obsolète, il doit plus être proposé dans les listes de saisie
221 * @param taxonNameObsolIn Boolean
222 */
223 public void setTaxonNameObsol(Boolean taxonNameObsolIn)
224 {
225 this.taxonNameObsol = taxonNameObsolIn;
226 }
227
228 private Boolean taxonNameTempor;
229
230 /**
231 * Vrai s'il s'agit d'une identification provisoire.
232 * @return this.taxonNameTempor Boolean
233 */
234 public Boolean getTaxonNameTempor()
235 {
236 return this.taxonNameTempor;
237 }
238
239 /**
240 * Vrai s'il s'agit d'une identification provisoire.
241 * @param taxonNameTemporIn Boolean
242 */
243 public void setTaxonNameTempor(Boolean taxonNameTemporIn)
244 {
245 this.taxonNameTempor = taxonNameTemporIn;
246 }
247
248 private Date taxonNameCreationDt;
249
250 /**
251 * Date de création de l'objet
252 * @return this.taxonNameCreationDt Date
253 */
254 public Date getTaxonNameCreationDt()
255 {
256 return this.taxonNameCreationDt;
257 }
258
259 /**
260 * Date de création de l'objet
261 * @param taxonNameCreationDtIn Date
262 */
263 public void setTaxonNameCreationDt(Date taxonNameCreationDtIn)
264 {
265 this.taxonNameCreationDt = taxonNameCreationDtIn;
266 }
267
268 private Timestamp updateDt;
269
270 /**
271 * Date de mise à jour de l'objet
272 * @return this.updateDt Timestamp
273 */
274 public Timestamp getUpdateDt()
275 {
276 return this.updateDt;
277 }
278
279 /**
280 * Date de mise à jour de l'objet
281 * @param updateDtIn Timestamp
282 */
283 public void setUpdateDt(Timestamp updateDtIn)
284 {
285 this.updateDt = updateDtIn;
286 }
287
288 private Date taxonStartDt;
289
290 /**
291 * Date de début de validité du taxon
292 * @return this.taxonStartDt Date
293 */
294 public Date getTaxonStartDt()
295 {
296 return this.taxonStartDt;
297 }
298
299 /**
300 * Date de début de validité du taxon
301 * @param taxonStartDtIn Date
302 */
303 public void setTaxonStartDt(Date taxonStartDtIn)
304 {
305 this.taxonStartDt = taxonStartDtIn;
306 }
307
308 private Date taxonEndDt;
309
310 /**
311 * Date de fin de validité du taxon
312 * @return this.taxonEndDt Date
313 */
314 public Date getTaxonEndDt()
315 {
316 return this.taxonEndDt;
317 }
318
319 /**
320 * Date de fin de validité du taxon
321 * @param taxonEndDtIn Date
322 */
323 public void setTaxonEndDt(Date taxonEndDtIn)
324 {
325 this.taxonEndDt = taxonEndDtIn;
326 }
327
328 // Generate 11 associations
329 private Citation citId;
330
331 /**
332 * Citation faisant référence pour un taxon particulier.
333 * @return this.citId Citation
334 */
335 public Citation getCitId()
336 {
337 return this.citId;
338 }
339
340 /**
341 * Citation faisant référence pour un taxon particulier.
342 * @param citIdIn Citation
343 */
344 public void setCitId(Citation citIdIn)
345 {
346 this.citId = citIdIn;
347 }
348
349 private Collection<AlternativeTaxon> alternativeTaxons = new HashSet<AlternativeTaxon>();
350
351 /**
352 * Contient les correspondances entre les taxons du système et les codes alternatifs des taxons
353 * provenant d'autres sources (autres systèmes, référentiels...)
354 * @return this.alternativeTaxons Collection<AlternativeTaxon>
355 */
356 public Collection<AlternativeTaxon> getAlternativeTaxons()
357 {
358 return this.alternativeTaxons;
359 }
360
361 /**
362 * Contient les correspondances entre les taxons du système et les codes alternatifs des taxons
363 * provenant d'autres sources (autres systèmes, référentiels...)
364 * @param alternativeTaxonsIn Collection<AlternativeTaxon>
365 */
366 public void setAlternativeTaxons(Collection<AlternativeTaxon> alternativeTaxonsIn)
367 {
368 this.alternativeTaxons = alternativeTaxonsIn;
369 }
370
371 /**
372 * Contient les correspondances entre les taxons du système et les codes alternatifs des taxons
373 * provenant d'autres sources (autres systèmes, référentiels...)
374 * @param elementToAdd AlternativeTaxon
375 * @return <tt>true</tt> if this collection changed as a result of the
376 * call
377 */
378 public boolean addAlternativeTaxons(AlternativeTaxon elementToAdd)
379 {
380 return this.alternativeTaxons.add(elementToAdd);
381 }
382
383 /**
384 * Contient les correspondances entre les taxons du système et les codes alternatifs des taxons
385 * provenant d'autres sources (autres systèmes, référentiels...)
386 * @param elementToRemove AlternativeTaxon
387 * @return <tt>true</tt> if this collection changed as a result of the
388 * call
389 */
390 public boolean removeAlternativeTaxons(AlternativeTaxon elementToRemove)
391 {
392 return this.alternativeTaxons.remove(elementToRemove);
393 }
394
395 private Collection<TaxonNameHistory> taxonNameHistories = new HashSet<TaxonNameHistory>();
396
397 /**
398 * Cette table permet de conserver l'historique des modifications d'un taxon
399 * @return this.taxonNameHistories Collection<TaxonNameHistory>
400 */
401 public Collection<TaxonNameHistory> getTaxonNameHistories()
402 {
403 return this.taxonNameHistories;
404 }
405
406 /**
407 * Cette table permet de conserver l'historique des modifications d'un taxon
408 * @param taxonNameHistoriesIn Collection<TaxonNameHistory>
409 */
410 public void setTaxonNameHistories(Collection<TaxonNameHistory> taxonNameHistoriesIn)
411 {
412 this.taxonNameHistories = taxonNameHistoriesIn;
413 }
414
415 /**
416 * Cette table permet de conserver l'historique des modifications d'un taxon
417 * @param elementToAdd TaxonNameHistory
418 * @return <tt>true</tt> if this collection changed as a result of the
419 * call
420 */
421 public boolean addTaxonNameHistories(TaxonNameHistory elementToAdd)
422 {
423 return this.taxonNameHistories.add(elementToAdd);
424 }
425
426 /**
427 * Cette table permet de conserver l'historique des modifications d'un taxon
428 * @param elementToRemove TaxonNameHistory
429 * @return <tt>true</tt> if this collection changed as a result of the
430 * call
431 */
432 public boolean removeTaxonNameHistories(TaxonNameHistory elementToRemove)
433 {
434 return this.taxonNameHistories.remove(elementToRemove);
435 }
436
437 private Collection<TaxonName> taxonNames = new HashSet<TaxonName>();
438
439 /**
440 * Liste les taxons (interface avec ERMS)
441 * @return this.taxonNames Collection<TaxonName>
442 */
443 public Collection<TaxonName> getTaxonNames()
444 {
445 return this.taxonNames;
446 }
447
448 /**
449 * Liste les taxons (interface avec ERMS)
450 * @param taxonNamesIn Collection<TaxonName>
451 */
452 public void setTaxonNames(Collection<TaxonName> taxonNamesIn)
453 {
454 this.taxonNames = taxonNamesIn;
455 }
456
457 /**
458 * Liste les taxons (interface avec ERMS)
459 * @param elementToAdd TaxonName
460 * @return <tt>true</tt> if this collection changed as a result of the
461 * call
462 */
463 public boolean addTaxonNames(TaxonName elementToAdd)
464 {
465 return this.taxonNames.add(elementToAdd);
466 }
467
468 /**
469 * Liste les taxons (interface avec ERMS)
470 * @param elementToRemove TaxonName
471 * @return <tt>true</tt> if this collection changed as a result of the
472 * call
473 */
474 public boolean removeTaxonNames(TaxonName elementToRemove)
475 {
476 return this.taxonNames.remove(elementToRemove);
477 }
478
479 private TaxonName parentTaxonName;
480
481 /**
482 * Liste les taxons (interface avec ERMS)
483 * @return this.parentTaxonName TaxonName
484 */
485 public TaxonName getParentTaxonName()
486 {
487 return this.parentTaxonName;
488 }
489
490 /**
491 * Liste les taxons (interface avec ERMS)
492 * @param parentTaxonNameIn TaxonName
493 */
494 public void setParentTaxonName(TaxonName parentTaxonNameIn)
495 {
496 this.parentTaxonName = parentTaxonNameIn;
497 }
498
499 private TaxonomicLevel taxonomicLevel;
500
501 /**
502 * Liste des niveaux systématiques des taxons.
503 * @return this.taxonomicLevel TaxonomicLevel
504 */
505 public TaxonomicLevel getTaxonomicLevel()
506 {
507 return this.taxonomicLevel;
508 }
509
510 /**
511 * Liste des niveaux systématiques des taxons.
512 * @param taxonomicLevelIn TaxonomicLevel
513 */
514 public void setTaxonomicLevel(TaxonomicLevel taxonomicLevelIn)
515 {
516 this.taxonomicLevel = taxonomicLevelIn;
517 }
518
519 private Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecords = new HashSet<TaxonGroupHistoricalRecord>();
520
521 /**
522 * Historique de l'évolution des contenus des groupes de taxons
523 * @return this.taxonGroupHistoricalRecords Collection<TaxonGroupHistoricalRecord>
524 */
525 public Collection<TaxonGroupHistoricalRecord> getTaxonGroupHistoricalRecords()
526 {
527 return this.taxonGroupHistoricalRecords;
528 }
529
530 /**
531 * Historique de l'évolution des contenus des groupes de taxons
532 * @param taxonGroupHistoricalRecordsIn Collection<TaxonGroupHistoricalRecord>
533 */
534 public void setTaxonGroupHistoricalRecords(Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecordsIn)
535 {
536 this.taxonGroupHistoricalRecords = taxonGroupHistoricalRecordsIn;
537 }
538
539 /**
540 * Historique de l'évolution des contenus des groupes de taxons
541 * @param elementToAdd TaxonGroupHistoricalRecord
542 * @return <tt>true</tt> if this collection changed as a result of the
543 * call
544 */
545 public boolean addTaxonGroupHistoricalRecords(TaxonGroupHistoricalRecord elementToAdd)
546 {
547 return this.taxonGroupHistoricalRecords.add(elementToAdd);
548 }
549
550 /**
551 * Historique de l'évolution des contenus des groupes de taxons
552 * @param elementToRemove TaxonGroupHistoricalRecord
553 * @return <tt>true</tt> if this collection changed as a result of the
554 * call
555 */
556 public boolean removeTaxonGroupHistoricalRecords(TaxonGroupHistoricalRecord elementToRemove)
557 {
558 return this.taxonGroupHistoricalRecords.remove(elementToRemove);
559 }
560
561 private ReferenceTaxon referenceTaxon;
562
563 /**
564 * Liste des taxons qui sont la référence.
565 * l'ID référent est indépendant des ID taxon car les taxons peuvent être référents à un moment
566 * et ne
567 * plus l'être par la suite.
568 * Toutes les données du système doivent donc être reliées au référent et non au taxon qui sont
569 * référents à un moment mais ne peuvent plus l'être par la suite.
570 * Le fonctionnement dans la table TAXON_NAME est le suivant :
571 * - REF_TAXON_ID est toujours renseigné
572 * - si TAXON_NAME_IS_REFER est à vrai, il s'agit d'un taxon référent (toujours le cas s'il
573 * s'agit d'un
574 * taxon virtuel)
575 * - sinon c'est un synonyme
576 * Un taxon référent qui devient synonyme voit donc son statut TAXON_NAME_IS_REFER changer et le
577 * nouveau taxon référent qui le remplace récupère l'information REF_TAXON_ID
578 * NB : c'était le comportement initialement prévu.
579 * En réalité, lorsqu'un taxon référent T1-R1 devient synonyme d'un nouveau taxon référent T2,
580 * le taxon
581 * T2 prend un nouveau code référent R2 et donc le taxon T1 est lié à R2 (et tous les synonymes
582 * et les
583 * résultats qu'il pouvait avoir).
584 * Ce mécanisme a été adopté car il fallait distinguer 2 cas :
585 * 1- cas d'un taxon référent T1-R1 qui devient synonyme d'un référent qu'on crée T2 : on aurait
586 * alors
587 * pu utiliser le même REF_TAXON_ID R1 au lieu d'en créer un et ne pas mettre à jour les autres
588 * synonymes, résultats...
589 * 2- cas d'un taxon référent T1-R1 qui devient synonyme d'un référent qui existe déjà T2-R2 (et
590 * qui
591 * aurait déjà d'autres synonymes, résultats...), dans ce cas le remplacement de la référence R1
592 * pour
593 * R2 est nécessaire
594 * La modélisation pourrait être revue car la table REFENCE_TAXON ne se justifie alors plus, on
595 * pourrait directement utiliser une référence à la colonne TAXON_NAME_ID pour désigner les
596 * référents
597 * @return this.referenceTaxon ReferenceTaxon
598 */
599 public ReferenceTaxon getReferenceTaxon()
600 {
601 return this.referenceTaxon;
602 }
603
604 /**
605 * Liste des taxons qui sont la référence.
606 * l'ID référent est indépendant des ID taxon car les taxons peuvent être référents à un moment
607 * et ne
608 * plus l'être par la suite.
609 * Toutes les données du système doivent donc être reliées au référent et non au taxon qui sont
610 * référents à un moment mais ne peuvent plus l'être par la suite.
611 * Le fonctionnement dans la table TAXON_NAME est le suivant :
612 * - REF_TAXON_ID est toujours renseigné
613 * - si TAXON_NAME_IS_REFER est à vrai, il s'agit d'un taxon référent (toujours le cas s'il
614 * s'agit d'un
615 * taxon virtuel)
616 * - sinon c'est un synonyme
617 * Un taxon référent qui devient synonyme voit donc son statut TAXON_NAME_IS_REFER changer et le
618 * nouveau taxon référent qui le remplace récupère l'information REF_TAXON_ID
619 * NB : c'était le comportement initialement prévu.
620 * En réalité, lorsqu'un taxon référent T1-R1 devient synonyme d'un nouveau taxon référent T2,
621 * le taxon
622 * T2 prend un nouveau code référent R2 et donc le taxon T1 est lié à R2 (et tous les synonymes
623 * et les
624 * résultats qu'il pouvait avoir).
625 * Ce mécanisme a été adopté car il fallait distinguer 2 cas :
626 * 1- cas d'un taxon référent T1-R1 qui devient synonyme d'un référent qu'on crée T2 : on aurait
627 * alors
628 * pu utiliser le même REF_TAXON_ID R1 au lieu d'en créer un et ne pas mettre à jour les autres
629 * synonymes, résultats...
630 * 2- cas d'un taxon référent T1-R1 qui devient synonyme d'un référent qui existe déjà T2-R2 (et
631 * qui
632 * aurait déjà d'autres synonymes, résultats...), dans ce cas le remplacement de la référence R1
633 * pour
634 * R2 est nécessaire
635 * La modélisation pourrait être revue car la table REFENCE_TAXON ne se justifie alors plus, on
636 * pourrait directement utiliser une référence à la colonne TAXON_NAME_ID pour désigner les
637 * référents
638 * @param referenceTaxonIn ReferenceTaxon
639 */
640 public void setReferenceTaxon(ReferenceTaxon referenceTaxonIn)
641 {
642 this.referenceTaxon = referenceTaxonIn;
643 }
644
645 private Collection<VirtualComponent> virtualComponents = new HashSet<VirtualComponent>();
646
647 /**
648 *
649 * @return this.virtualComponents Collection<VirtualComponent>
650 */
651 public Collection<VirtualComponent> getVirtualComponents()
652 {
653 return this.virtualComponents;
654 }
655
656 /**
657 *
658 * @param virtualComponentsIn Collection<VirtualComponent>
659 */
660 public void setVirtualComponents(Collection<VirtualComponent> virtualComponentsIn)
661 {
662 this.virtualComponents = virtualComponentsIn;
663 }
664
665 /**
666 *
667 * @param elementToAdd VirtualComponent
668 * @return <tt>true</tt> if this collection changed as a result of the
669 * call
670 */
671 public boolean addVirtualComponents(VirtualComponent elementToAdd)
672 {
673 return this.virtualComponents.add(elementToAdd);
674 }
675
676 /**
677 *
678 * @param elementToRemove VirtualComponent
679 * @return <tt>true</tt> if this collection changed as a result of the
680 * call
681 */
682 public boolean removeVirtualComponents(VirtualComponent elementToRemove)
683 {
684 return this.virtualComponents.remove(elementToRemove);
685 }
686
687 /**
688 * Returns <code>true</code> if the argument is an TaxonName instance and all identifiers for this entity
689 * equal the identifiers of the argument entity. Returns <code>false</code> otherwise.
690 */
691 @Override
692 public boolean equals(Object object)
693 {
694 if (this == object)
695 {
696 return true;
697 }
698 if (!(object instanceof TaxonName))
699 {
700 return false;
701 }
702 final TaxonName that = (TaxonName)object;
703 if (this.taxonNameId == null || that.getTaxonNameId() == null || !this.taxonNameId.equals(that.getTaxonNameId()))
704 {
705 return false;
706 }
707 return true;
708 }
709
710 /**
711 * Returns a hash code based on this entity's identifiers.
712 */
713 @Override
714 public int hashCode()
715 {
716 int hashCode = 0;
717 hashCode = 29 * hashCode + (this.taxonNameId == null ? 0 : this.taxonNameId.hashCode());
718
719 return hashCode;
720 }
721
722 /**
723 * Constructs new instances of {@link TaxonName}.
724 */
725 public static final class Factory
726 {
727 /**
728 * Constructs a new instance of {@link TaxonName}.
729 * @return new TaxonNameImpl()
730 */
731 public static TaxonName newInstance()
732 {
733 return new TaxonNameImpl();
734 }
735
736 /**
737 * Constructs a new instance of {@link TaxonName}, taking all required and/or
738 * read-only properties as arguments, except for identifiers.
739 * @param updateDt Timestamp
740 * @param taxonomicLevel TaxonomicLevel
741 * @param referenceTaxon ReferenceTaxon
742 * @return newInstance
743 */
744 public static TaxonName newInstance(Timestamp updateDt, TaxonomicLevel taxonomicLevel, ReferenceTaxon referenceTaxon)
745 {
746 final TaxonName entity = new TaxonNameImpl();
747 entity.setUpdateDt(updateDt);
748 entity.setTaxonomicLevel(taxonomicLevel);
749 entity.setReferenceTaxon(referenceTaxon);
750 return entity;
751 }
752
753 /**
754 * Constructs a new instance of {@link TaxonName}, taking all possible properties
755 * (except the identifier(s))as arguments.
756 * @param taxonNameNm String
757 * @param taxonNameCompleteNm String
758 * @param taxonNameIsNaming Boolean
759 * @param taxonNameCm String
760 * @param taxonNameUpperRk Integer
761 * @param taxonNameIsRefer Boolean
762 * @param taxonNameIsVirtual Boolean
763 * @param taxonNameObsol Boolean
764 * @param taxonNameTempor Boolean
765 * @param taxonNameCreationDt Date
766 * @param updateDt Timestamp
767 * @param taxonStartDt Date
768 * @param taxonEndDt Date
769 * @param citId Citation
770 * @param alternativeTaxons Collection<AlternativeTaxon>
771 * @param taxonNameHistories Collection<TaxonNameHistory>
772 * @param taxonNames Collection<TaxonName>
773 * @param parentTaxonName TaxonName
774 * @param taxonomicLevel TaxonomicLevel
775 * @param taxonGroupHistoricalRecords Collection<TaxonGroupHistoricalRecord>
776 * @param referenceTaxon ReferenceTaxon
777 * @param virtualComponents Collection<VirtualComponent>
778 * @return newInstance TaxonName
779 */
780 public static TaxonName newInstance(String taxonNameNm, String taxonNameCompleteNm, Boolean taxonNameIsNaming, String taxonNameCm, Integer taxonNameUpperRk, Boolean taxonNameIsRefer, Boolean taxonNameIsVirtual, Boolean taxonNameObsol, Boolean taxonNameTempor, Date taxonNameCreationDt, Timestamp updateDt, Date taxonStartDt, Date taxonEndDt, Citation citId, Collection<AlternativeTaxon> alternativeTaxons, Collection<TaxonNameHistory> taxonNameHistories, Collection<TaxonName> taxonNames, TaxonName parentTaxonName, TaxonomicLevel taxonomicLevel, Collection<TaxonGroupHistoricalRecord> taxonGroupHistoricalRecords, ReferenceTaxon referenceTaxon, Collection<VirtualComponent> virtualComponents)
781 {
782 final TaxonName entity = new TaxonNameImpl();
783 entity.setTaxonNameNm(taxonNameNm);
784 entity.setTaxonNameCompleteNm(taxonNameCompleteNm);
785 entity.setTaxonNameIsNaming(taxonNameIsNaming);
786 entity.setTaxonNameCm(taxonNameCm);
787 entity.setTaxonNameUpperRk(taxonNameUpperRk);
788 entity.setTaxonNameIsRefer(taxonNameIsRefer);
789 entity.setTaxonNameIsVirtual(taxonNameIsVirtual);
790 entity.setTaxonNameObsol(taxonNameObsol);
791 entity.setTaxonNameTempor(taxonNameTempor);
792 entity.setTaxonNameCreationDt(taxonNameCreationDt);
793 entity.setUpdateDt(updateDt);
794 entity.setTaxonStartDt(taxonStartDt);
795 entity.setTaxonEndDt(taxonEndDt);
796 entity.setCitId(citId);
797 entity.setAlternativeTaxons(alternativeTaxons);
798 entity.setTaxonNameHistories(taxonNameHistories);
799 entity.setTaxonNames(taxonNames);
800 entity.setParentTaxonName(parentTaxonName);
801 entity.setTaxonomicLevel(taxonomicLevel);
802 entity.setTaxonGroupHistoricalRecords(taxonGroupHistoricalRecords);
803 entity.setReferenceTaxon(referenceTaxon);
804 entity.setVirtualComponents(virtualComponents);
805 return entity;
806 }
807 }
808
809 /**
810 * @see Comparable#compareTo
811 */
812 public int compareTo(TaxonName o)
813 {
814 int cmp = 0;
815 if (this.getTaxonNameId() != null)
816 {
817 cmp = this.getTaxonNameId().compareTo(o.getTaxonNameId());
818 }
819 else
820 {
821 if (this.getTaxonNameNm() != null)
822 {
823 cmp = (cmp != 0 ? cmp : this.getTaxonNameNm().compareTo(o.getTaxonNameNm()));
824 }
825 if (this.getTaxonNameCompleteNm() != null)
826 {
827 cmp = (cmp != 0 ? cmp : this.getTaxonNameCompleteNm().compareTo(o.getTaxonNameCompleteNm()));
828 }
829 if (this.getTaxonNameIsNaming() != null)
830 {
831 cmp = (cmp != 0 ? cmp : this.getTaxonNameIsNaming().compareTo(o.getTaxonNameIsNaming()));
832 }
833 if (this.getTaxonNameCm() != null)
834 {
835 cmp = (cmp != 0 ? cmp : this.getTaxonNameCm().compareTo(o.getTaxonNameCm()));
836 }
837 if (this.getTaxonNameUpperRk() != null)
838 {
839 cmp = (cmp != 0 ? cmp : this.getTaxonNameUpperRk().compareTo(o.getTaxonNameUpperRk()));
840 }
841 if (this.getTaxonNameIsRefer() != null)
842 {
843 cmp = (cmp != 0 ? cmp : this.getTaxonNameIsRefer().compareTo(o.getTaxonNameIsRefer()));
844 }
845 if (this.getTaxonNameIsVirtual() != null)
846 {
847 cmp = (cmp != 0 ? cmp : this.getTaxonNameIsVirtual().compareTo(o.getTaxonNameIsVirtual()));
848 }
849 if (this.getTaxonNameObsol() != null)
850 {
851 cmp = (cmp != 0 ? cmp : this.getTaxonNameObsol().compareTo(o.getTaxonNameObsol()));
852 }
853 if (this.getTaxonNameTempor() != null)
854 {
855 cmp = (cmp != 0 ? cmp : this.getTaxonNameTempor().compareTo(o.getTaxonNameTempor()));
856 }
857 if (this.getTaxonNameCreationDt() != null)
858 {
859 cmp = (cmp != 0 ? cmp : this.getTaxonNameCreationDt().compareTo(o.getTaxonNameCreationDt()));
860 }
861 if (this.getUpdateDt() != null)
862 {
863 cmp = (cmp != 0 ? cmp : this.getUpdateDt().compareTo(o.getUpdateDt()));
864 }
865 if (this.getTaxonStartDt() != null)
866 {
867 cmp = (cmp != 0 ? cmp : this.getTaxonStartDt().compareTo(o.getTaxonStartDt()));
868 }
869 if (this.getTaxonEndDt() != null)
870 {
871 cmp = (cmp != 0 ? cmp : this.getTaxonEndDt().compareTo(o.getTaxonEndDt()));
872 }
873 }
874 return cmp;
875 }
876 // HibernateEntity.vsl merge-point
877 // TaxonName.java merge-point
878 }