Source code

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.administration.programStrategy;
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.administration.user.Person;
032import fr.ifremer.adagio.core.dao.referential.gear.Gear;
033import java.io.Serializable;
034import java.sql.Timestamp;
035import java.util.Collection;
036import java.util.Date;
037import java.util.HashSet;
038
039/**
040 * La stratégie définit a priori ce que devront être les données présentes dans le système de
041 * l'origine de la collecte des données. Il s'agit de la liste des paramètres à mesurer, ainsi que
042 * des méthodes préconisées pour chacun de ces paramètres. La stratégie permet ainsi d'aider à la
043 * saisie des données, en personnalisant les écrans, et facilite la consultation rapide du contenu
044 * théorique de la base.
045 * Par exemple, on pourra avoir les stratégies suivantes :
046 * - stratégie "échantillonnage pendant les marées observées"
047 * - stratégie "échantillonnage pendant les campagne à la mer"
048 */
049// HibernateEntity.vsl annotations merge-point
050public abstract class Strategy
051    implements Serializable, Comparable<Strategy>
052{
053    /**
054     * The serial version UID of this class. Needed for serialization.
055     */
056    private static final long serialVersionUID = 3391613597864647219L;
057
058    // Generate 5 attributes
059    private Integer id;
060
061    /**
062     * Identifiant interne. généré par le système.
063     * @return this.id Integer
064     */
065    public Integer getId()
066    {
067        return this.id;
068    }
069
070    /**
071     * Identifiant interne. généré par le système.
072     * @param idIn Integer
073     */
074    public void setId(Integer idIn)
075    {
076        this.id = idIn;
077    }
078
079    private String name;
080
081    /**
082     * 
083     * @return this.name String
084     */
085    public String getName()
086    {
087        return this.name;
088    }
089
090    /**
091     * 
092     * @param nameIn String
093     */
094    public void setName(String nameIn)
095    {
096        this.name = nameIn;
097    }
098
099    private String description;
100
101    /**
102     * 
103     * @return this.description String
104     */
105    public String getDescription()
106    {
107        return this.description;
108    }
109
110    /**
111     * 
112     * @param descriptionIn String
113     */
114    public void setDescription(String descriptionIn)
115    {
116        this.description = descriptionIn;
117    }
118
119    private Date creationDate;
120
121    /**
122     * 
123     * @return this.creationDate Date
124     */
125    public Date getCreationDate()
126    {
127        return this.creationDate;
128    }
129
130    /**
131     * 
132     * @param creationDateIn Date
133     */
134    public void setCreationDate(Date creationDateIn)
135    {
136        this.creationDate = creationDateIn;
137    }
138
139    private Timestamp updateDate;
140
141    /**
142     * 
143     * @return this.updateDate Timestamp
144     */
145    public Timestamp getUpdateDate()
146    {
147        return this.updateDate;
148    }
149
150    /**
151     * 
152     * @param updateDateIn Timestamp
153     */
154    public void setUpdateDate(Timestamp updateDateIn)
155    {
156        this.updateDate = updateDateIn;
157    }
158
159    // Generate 6 associations
160    private Collection<ReferenceTaxonStrategy> referenceTaxonStrategies = new HashSet<ReferenceTaxonStrategy>();
161
162    /**
163     * Définit les Taxons relatifs à une stratégie de collecte, éventuellement le niveau de priorité
164     * de la
165     * collecte sur le Taxon.
166     * @return this.referenceTaxonStrategies Collection<ReferenceTaxonStrategy>
167     */
168    public Collection<ReferenceTaxonStrategy> getReferenceTaxonStrategies()
169    {
170        return this.referenceTaxonStrategies;
171    }
172
173    /**
174     * Définit les Taxons relatifs à une stratégie de collecte, éventuellement le niveau de priorité
175     * de la
176     * collecte sur le Taxon.
177     * @param referenceTaxonStrategiesIn Collection<ReferenceTaxonStrategy>
178     */
179    public void setReferenceTaxonStrategies(Collection<ReferenceTaxonStrategy> referenceTaxonStrategiesIn)
180    {
181        this.referenceTaxonStrategies = referenceTaxonStrategiesIn;
182    }
183
184    /**
185     * Définit les Taxons relatifs à une stratégie de collecte, éventuellement le niveau de priorité
186     * de la
187     * collecte sur le Taxon.
188     * @param elementToAdd ReferenceTaxonStrategy
189     * @return <tt>true</tt> if this collection changed as a result of the
190     *         call
191     */
192    public boolean addReferenceTaxonStrategies(ReferenceTaxonStrategy elementToAdd)
193    {
194        return this.referenceTaxonStrategies.add(elementToAdd);
195    }
196
197    /**
198     * Définit les Taxons relatifs à une stratégie de collecte, éventuellement le niveau de priorité
199     * de la
200     * collecte sur le Taxon.
201     * @param elementToRemove ReferenceTaxonStrategy
202     * @return <tt>true</tt> if this collection changed as a result of the
203     *         call
204     */
205    public boolean removeReferenceTaxonStrategies(ReferenceTaxonStrategy elementToRemove)
206    {
207        return this.referenceTaxonStrategies.remove(elementToRemove);
208    }
209
210    private Collection<Person> managersUsers = new HashSet<Person>();
211
212    /**
213     * <html>
214     * <head>
215     * <style>
216     * p {padding:0px; margin:0px;}
217     * </style>
218     * </head>
219     * <body>
220     * <p>
221     * Personne liées aux données : utilisateur du système, ou observateurs,
222     * responsable de données, etc.
223     * </p>
224     * <p>
225     * </p>
226     * <p>
227     * Les personnes liées aux activités professionnelles de pêche sont plutôt
228     * gérer dans <i>VesselPerson</i>.
229     * </p>
230     * <p>
231     * </p>
232     * <p>
233     * Nombre de lignes : 100
234     * </p>
235     * </body>
236     * </html>
237     * @return this.managersUsers Collection<Person>
238     */
239    public Collection<Person> getManagersUsers()
240    {
241        return this.managersUsers;
242    }
243
244    /**
245     * <html>
246     * <head>
247     * <style>
248     * p {padding:0px; margin:0px;}
249     * </style>
250     * </head>
251     * <body>
252     * <p>
253     * Personne liées aux données : utilisateur du système, ou observateurs,
254     * responsable de données, etc.
255     * </p>
256     * <p>
257     * </p>
258     * <p>
259     * Les personnes liées aux activités professionnelles de pêche sont plutôt
260     * gérer dans <i>VesselPerson</i>.
261     * </p>
262     * <p>
263     * </p>
264     * <p>
265     * Nombre de lignes : 100
266     * </p>
267     * </body>
268     * </html>
269     * @param managersUsersIn Collection<Person>
270     */
271    public void setManagersUsers(Collection<Person> managersUsersIn)
272    {
273        this.managersUsers = managersUsersIn;
274    }
275
276    /**
277     * <html>
278     * <head>
279     * <style>
280     * p {padding:0px; margin:0px;}
281     * </style>
282     * </head>
283     * <body>
284     * <p>
285     * Personne liées aux données : utilisateur du système, ou observateurs,
286     * responsable de données, etc.
287     * </p>
288     * <p>
289     * </p>
290     * <p>
291     * Les personnes liées aux activités professionnelles de pêche sont plutôt
292     * gérer dans <i>VesselPerson</i>.
293     * </p>
294     * <p>
295     * </p>
296     * <p>
297     * Nombre de lignes : 100
298     * </p>
299     * </body>
300     * </html>
301     * @param elementToAdd Person
302     * @return <tt>true</tt> if this collection changed as a result of the
303     *         call
304     */
305    public boolean addManagersUsers(Person elementToAdd)
306    {
307        return this.managersUsers.add(elementToAdd);
308    }
309
310    /**
311     * <html>
312     * <head>
313     * <style>
314     * p {padding:0px; margin:0px;}
315     * </style>
316     * </head>
317     * <body>
318     * <p>
319     * Personne liées aux données : utilisateur du système, ou observateurs,
320     * responsable de données, etc.
321     * </p>
322     * <p>
323     * </p>
324     * <p>
325     * Les personnes liées aux activités professionnelles de pêche sont plutôt
326     * gérer dans <i>VesselPerson</i>.
327     * </p>
328     * <p>
329     * </p>
330     * <p>
331     * Nombre de lignes : 100
332     * </p>
333     * </body>
334     * </html>
335     * @param elementToRemove Person
336     * @return <tt>true</tt> if this collection changed as a result of the
337     *         call
338     */
339    public boolean removeManagersUsers(Person elementToRemove)
340    {
341        return this.managersUsers.remove(elementToRemove);
342    }
343
344    private Collection<Gear> gears = new HashSet<Gear>();
345
346    /**
347     * <html>
348     * <head>
349     * </head>
350     * <body>
351     * <p>
352     * D&#233;fini un engin, non pas engin physique, mais au sens &quot;classe d'engin&quot;.
353     * </p>
354     * <p>
355     * Il est possible de d&#233;finir un arboresence d'engin, au sein d'une meme
356     * classification, via les liens d'engin parents/enfants.
357     * </p>
358     * <p>
359     * <br>
360     * </p>
361     * <p>
362     * Exemple, pour la classification 'Engin EU corpus' :
363     * </p>
364     * <p>
365     * * 'corpus effort de p&#234;che'<br>- PAL Palangre de surface (Longliner)<br>
366     * </p>
367     * <p>
368     * - EP1 Engins petits p&#233;lagiques - corpus r&#233;glementaire 685/95
369     * </p>
370     * <p>
371     * * corpus 2 (...)<br>- ...
372     * </p>
373     * <p>
374     * <br>
375     * </p>
376     * <p>
377     * Exemple, pour la classification 'FAO/CISTEP' :<br>* 'chaluts' (code
378     * '03.0.0')<br>
379     * </p>
380     * <p>
381     * - 'OTB' 'chalut de fond'<br>
382     * </p>
383     * <p>
384     * - chalut p&#233;lagique
385     * </p>
386     * <p>
387     * - ...<br>* 'Filets'
388     * </p>
389     * </body>
390     * </html>
391     * @return this.gears Collection<Gear>
392     */
393    public Collection<Gear> getGears()
394    {
395        return this.gears;
396    }
397
398    /**
399     * <html>
400     * <head>
401     * </head>
402     * <body>
403     * <p>
404     * D&#233;fini un engin, non pas engin physique, mais au sens &quot;classe d'engin&quot;.
405     * </p>
406     * <p>
407     * Il est possible de d&#233;finir un arboresence d'engin, au sein d'une meme
408     * classification, via les liens d'engin parents/enfants.
409     * </p>
410     * <p>
411     * <br>
412     * </p>
413     * <p>
414     * Exemple, pour la classification 'Engin EU corpus' :
415     * </p>
416     * <p>
417     * * 'corpus effort de p&#234;che'<br>- PAL Palangre de surface (Longliner)<br>
418     * </p>
419     * <p>
420     * - EP1 Engins petits p&#233;lagiques - corpus r&#233;glementaire 685/95
421     * </p>
422     * <p>
423     * * corpus 2 (...)<br>- ...
424     * </p>
425     * <p>
426     * <br>
427     * </p>
428     * <p>
429     * Exemple, pour la classification 'FAO/CISTEP' :<br>* 'chaluts' (code
430     * '03.0.0')<br>
431     * </p>
432     * <p>
433     * - 'OTB' 'chalut de fond'<br>
434     * </p>
435     * <p>
436     * - chalut p&#233;lagique
437     * </p>
438     * <p>
439     * - ...<br>* 'Filets'
440     * </p>
441     * </body>
442     * </html>
443     * @param gearsIn Collection<Gear>
444     */
445    public void setGears(Collection<Gear> gearsIn)
446    {
447        this.gears = gearsIn;
448    }
449
450    /**
451     * <html>
452     * <head>
453     * </head>
454     * <body>
455     * <p>
456     * D&#233;fini un engin, non pas engin physique, mais au sens &quot;classe d'engin&quot;.
457     * </p>
458     * <p>
459     * Il est possible de d&#233;finir un arboresence d'engin, au sein d'une meme
460     * classification, via les liens d'engin parents/enfants.
461     * </p>
462     * <p>
463     * <br>
464     * </p>
465     * <p>
466     * Exemple, pour la classification 'Engin EU corpus' :
467     * </p>
468     * <p>
469     * * 'corpus effort de p&#234;che'<br>- PAL Palangre de surface (Longliner)<br>
470     * </p>
471     * <p>
472     * - EP1 Engins petits p&#233;lagiques - corpus r&#233;glementaire 685/95
473     * </p>
474     * <p>
475     * * corpus 2 (...)<br>- ...
476     * </p>
477     * <p>
478     * <br>
479     * </p>
480     * <p>
481     * Exemple, pour la classification 'FAO/CISTEP' :<br>* 'chaluts' (code
482     * '03.0.0')<br>
483     * </p>
484     * <p>
485     * - 'OTB' 'chalut de fond'<br>
486     * </p>
487     * <p>
488     * - chalut p&#233;lagique
489     * </p>
490     * <p>
491     * - ...<br>* 'Filets'
492     * </p>
493     * </body>
494     * </html>
495     * @param elementToAdd Gear
496     * @return <tt>true</tt> if this collection changed as a result of the
497     *         call
498     */
499    public boolean addGears(Gear elementToAdd)
500    {
501        return this.gears.add(elementToAdd);
502    }
503
504    /**
505     * <html>
506     * <head>
507     * </head>
508     * <body>
509     * <p>
510     * D&#233;fini un engin, non pas engin physique, mais au sens &quot;classe d'engin&quot;.
511     * </p>
512     * <p>
513     * Il est possible de d&#233;finir un arboresence d'engin, au sein d'une meme
514     * classification, via les liens d'engin parents/enfants.
515     * </p>
516     * <p>
517     * <br>
518     * </p>
519     * <p>
520     * Exemple, pour la classification 'Engin EU corpus' :
521     * </p>
522     * <p>
523     * * 'corpus effort de p&#234;che'<br>- PAL Palangre de surface (Longliner)<br>
524     * </p>
525     * <p>
526     * - EP1 Engins petits p&#233;lagiques - corpus r&#233;glementaire 685/95
527     * </p>
528     * <p>
529     * * corpus 2 (...)<br>- ...
530     * </p>
531     * <p>
532     * <br>
533     * </p>
534     * <p>
535     * Exemple, pour la classification 'FAO/CISTEP' :<br>* 'chaluts' (code
536     * '03.0.0')<br>
537     * </p>
538     * <p>
539     * - 'OTB' 'chalut de fond'<br>
540     * </p>
541     * <p>
542     * - chalut p&#233;lagique
543     * </p>
544     * <p>
545     * - ...<br>* 'Filets'
546     * </p>
547     * </body>
548     * </html>
549     * @param elementToRemove Gear
550     * @return <tt>true</tt> if this collection changed as a result of the
551     *         call
552     */
553    public boolean removeGears(Gear elementToRemove)
554    {
555        return this.gears.remove(elementToRemove);
556    }
557
558    private Collection<PmfmStrategy> pmfmStrategies = new HashSet<PmfmStrategy>();
559
560    /**
561     * 
562     * @return this.pmfmStrategies Collection<PmfmStrategy>
563     */
564    public Collection<PmfmStrategy> getPmfmStrategies()
565    {
566        return this.pmfmStrategies;
567    }
568
569    /**
570     * 
571     * @param pmfmStrategiesIn Collection<PmfmStrategy>
572     */
573    public void setPmfmStrategies(Collection<PmfmStrategy> pmfmStrategiesIn)
574    {
575        this.pmfmStrategies = pmfmStrategiesIn;
576    }
577
578    /**
579     * 
580     * @param elementToAdd PmfmStrategy
581     * @return <tt>true</tt> if this collection changed as a result of the
582     *         call
583     */
584    public boolean addPmfmStrategies(PmfmStrategy elementToAdd)
585    {
586        return this.pmfmStrategies.add(elementToAdd);
587    }
588
589    /**
590     * 
591     * @param elementToRemove PmfmStrategy
592     * @return <tt>true</tt> if this collection changed as a result of the
593     *         call
594     */
595    public boolean removePmfmStrategies(PmfmStrategy elementToRemove)
596    {
597        return this.pmfmStrategies.remove(elementToRemove);
598    }
599
600    private Program program;
601
602    /**
603     * Programme d'observation à l'origine d'une collecte de données.
604     * Désigne les activités qui sont à l'origine de la collecte d'un ensemble cohérent de données,
605     * que ce
606     * soit pour des collectes continues (marées observées en mer, SIPA) ou pour des études limitées
607     * dans
608     * le temps. La quantité de données rattachées à un programme peut être variable, selon qu'il
609     * s'agit
610     * d'une activité longue ou intensive, ou d'une opération plus ponctuelle (étude) mais toujours
611     * mise en
612     * œuvre selon un schéma décidé à l'avance.
613     * Exemple de programmes d'observations :
614     * - SIH-OBSMER (marées observées en mer)
615     * - SIH-STATPECHE (enquete d'activité et d'effort...)
616     * - SIPA : données déclaratives transmises par la DPMA
617     * - VMS : données satellitaires
618     * - OFIMER : données du SI de l'OFIMER
619     * @return this.program Program
620     */
621    public Program getProgram()
622    {
623        return this.program;
624    }
625
626    /**
627     * Programme d'observation à l'origine d'une collecte de données.
628     * Désigne les activités qui sont à l'origine de la collecte d'un ensemble cohérent de données,
629     * que ce
630     * soit pour des collectes continues (marées observées en mer, SIPA) ou pour des études limitées
631     * dans
632     * le temps. La quantité de données rattachées à un programme peut être variable, selon qu'il
633     * s'agit
634     * d'une activité longue ou intensive, ou d'une opération plus ponctuelle (étude) mais toujours
635     * mise en
636     * œuvre selon un schéma décidé à l'avance.
637     * Exemple de programmes d'observations :
638     * - SIH-OBSMER (marées observées en mer)
639     * - SIH-STATPECHE (enquete d'activité et d'effort...)
640     * - SIPA : données déclaratives transmises par la DPMA
641     * - VMS : données satellitaires
642     * - OFIMER : données du SI de l'OFIMER
643     * @param programIn Program
644     */
645    public void setProgram(Program programIn)
646    {
647        this.program = programIn;
648    }
649
650    private Collection<AppliedStrategy> appliedStrategies = new HashSet<AppliedStrategy>();
651
652    /**
653     * Une stratégie applicable est la stratégie qui s'applique pour un lieu de surveillance donné
654     * durant
655     * un interval de dates défini.
656     * @return this.appliedStrategies Collection<AppliedStrategy>
657     */
658    public Collection<AppliedStrategy> getAppliedStrategies()
659    {
660        return this.appliedStrategies;
661    }
662
663    /**
664     * Une stratégie applicable est la stratégie qui s'applique pour un lieu de surveillance donné
665     * durant
666     * un interval de dates défini.
667     * @param appliedStrategiesIn Collection<AppliedStrategy>
668     */
669    public void setAppliedStrategies(Collection<AppliedStrategy> appliedStrategiesIn)
670    {
671        this.appliedStrategies = appliedStrategiesIn;
672    }
673
674    /**
675     * Une stratégie applicable est la stratégie qui s'applique pour un lieu de surveillance donné
676     * durant
677     * un interval de dates défini.
678     * @param elementToAdd AppliedStrategy
679     * @return <tt>true</tt> if this collection changed as a result of the
680     *         call
681     */
682    public boolean addAppliedStrategies(AppliedStrategy elementToAdd)
683    {
684        return this.appliedStrategies.add(elementToAdd);
685    }
686
687    /**
688     * Une stratégie applicable est la stratégie qui s'applique pour un lieu de surveillance donné
689     * durant
690     * un interval de dates défini.
691     * @param elementToRemove AppliedStrategy
692     * @return <tt>true</tt> if this collection changed as a result of the
693     *         call
694     */
695    public boolean removeAppliedStrategies(AppliedStrategy elementToRemove)
696    {
697        return this.appliedStrategies.remove(elementToRemove);
698    }
699
700    /**
701     * Returns <code>true</code> if the argument is an Strategy instance and all identifiers for this entity
702     * equal the identifiers of the argument entity. Returns <code>false</code> otherwise.
703     */
704    @Override
705    public boolean equals(Object object)
706    {
707        if (this == object)
708        {
709            return true;
710        }
711        if (!(object instanceof Strategy))
712        {
713            return false;
714        }
715        final Strategy that = (Strategy)object;
716        if (this.id == null || that.getId() == null || !this.id.equals(that.getId()))
717        {
718            return false;
719        }
720        return true;
721    }
722
723    /**
724     * Returns a hash code based on this entity's identifiers.
725     */
726    @Override
727    public int hashCode()
728    {
729        int hashCode = 0;
730        hashCode = 29 * hashCode + (this.id == null ? 0 : this.id.hashCode());
731
732        return hashCode;
733    }
734
735    /**
736     * Constructs new instances of {@link Strategy}.
737     */
738    public static final class Factory
739    {
740        /**
741         * Constructs a new instance of {@link Strategy}.
742         * @return new StrategyImpl()
743         */
744        public static Strategy newInstance()
745        {
746            return new StrategyImpl();
747        }
748
749        /**
750         * Constructs a new instance of {@link Strategy}, taking all required and/or
751         * read-only properties as arguments, except for identifiers.
752         * @param name String
753         * @param description String
754         * @param creationDate Date
755         * @param updateDate Timestamp
756         * @param managersUsers Collection<Person>
757         * @param program Program
758         * @return newInstance
759         */
760        public static Strategy newInstance(String name, String description, Date creationDate, Timestamp updateDate, Collection<Person> managersUsers, Program program)
761        {
762            final Strategy entity = new StrategyImpl();
763            entity.setName(name);
764            entity.setDescription(description);
765            entity.setCreationDate(creationDate);
766            entity.setUpdateDate(updateDate);
767            entity.setManagersUsers(managersUsers);
768            entity.setProgram(program);
769            return entity;
770        }
771
772        /**
773         * Constructs a new instance of {@link Strategy}, taking all possible properties
774         * (except the identifier(s))as arguments.
775         * @param name String
776         * @param description String
777         * @param creationDate Date
778         * @param updateDate Timestamp
779         * @param referenceTaxonStrategies Collection<ReferenceTaxonStrategy>
780         * @param managersUsers Collection<Person>
781         * @param gears Collection<Gear>
782         * @param pmfmStrategies Collection<PmfmStrategy>
783         * @param program Program
784         * @param appliedStrategies Collection<AppliedStrategy>
785         * @return newInstance Strategy
786         */
787        public static Strategy newInstance(String name, String description, Date creationDate, Timestamp updateDate, Collection<ReferenceTaxonStrategy> referenceTaxonStrategies, Collection<Person> managersUsers, Collection<Gear> gears, Collection<PmfmStrategy> pmfmStrategies, Program program, Collection<AppliedStrategy> appliedStrategies)
788        {
789            final Strategy entity = new StrategyImpl();
790            entity.setName(name);
791            entity.setDescription(description);
792            entity.setCreationDate(creationDate);
793            entity.setUpdateDate(updateDate);
794            entity.setReferenceTaxonStrategies(referenceTaxonStrategies);
795            entity.setManagersUsers(managersUsers);
796            entity.setGears(gears);
797            entity.setPmfmStrategies(pmfmStrategies);
798            entity.setProgram(program);
799            entity.setAppliedStrategies(appliedStrategies);
800            return entity;
801        }
802    }
803
804    /**
805     * @see Comparable#compareTo
806     */
807    public int compareTo(Strategy o)
808    {
809        int cmp = 0;
810        if (this.getId() != null)
811        {
812            cmp = this.getId().compareTo(o.getId());
813        }
814        else
815        {
816            if (this.getName() != null)
817            {
818                cmp = (cmp != 0 ? cmp : this.getName().compareTo(o.getName()));
819            }
820            if (this.getDescription() != null)
821            {
822                cmp = (cmp != 0 ? cmp : this.getDescription().compareTo(o.getDescription()));
823            }
824            if (this.getCreationDate() != null)
825            {
826                cmp = (cmp != 0 ? cmp : this.getCreationDate().compareTo(o.getCreationDate()));
827            }
828            if (this.getUpdateDate() != null)
829            {
830                cmp = (cmp != 0 ? cmp : this.getUpdateDate().compareTo(o.getUpdateDate()));
831            }
832        }
833        return cmp;
834    }
835// HibernateEntity.vsl merge-point
836// Strategy.java merge-point
837}