cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/occurrence/DeterminationEvent.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.occurrence;
  11
  12
  13 import eu.etaxonomy.cdm.model.agent.Agent;
  14 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  15 import eu.etaxonomy.cdm.model.taxon.Taxon;
  16 import org.apache.log4j.Logger;
  17 import org.hibernate.annotations.Cascade;
  18 import org.hibernate.annotations.CascadeType;
  19
  20 import eu.etaxonomy.cdm.model.common.EventBase;
  21
  22 import java.util.*;
  23
  24 import javax.persistence.*;
  25
  26 /**
  27  * @author m.doering
  28  * @version 1.0
  29  * @created 08-Nov-2007 13:06:21
  30  */
  31 @Entity
  32 public class DeterminationEvent extends EventBase {
  33         private static final Logger logger = Logger.getLogger(DeterminationEvent.class);
  34
  35         private SpecimenOrObservationBase identifiedUnit;
  36         private Taxon taxon;
  37         private DeterminationModifier modifier;
  38         private boolean preferredFlag;
  39         private Set<ReferenceBase> setOfReferences = getNewReferencesSet();
  40
  41
  42
  43         /**
  44          * Factory method
  45          * @return
  46          */
  47         public static DeterminationEvent NewInstance(){
  48                 return new DeterminationEvent();
  49         }
  50
  51         /**
  52          * Constructor
  53          */
  54         protected DeterminationEvent() {
  55                 super();
  56         }
  57
  58         @ManyToOne
  59         @Cascade( { CascadeType.SAVE_UPDATE })
  60         public DeterminationModifier getModifier() {
  61                 return modifier;
  62         }
  63
  64         public void setModifier(DeterminationModifier modifier) {
  65                 this.modifier = modifier;
  66         }
  67
  68         @ManyToOne
  69         @Cascade( { CascadeType.SAVE_UPDATE })
  70         public Taxon getTaxon(){
  71                 return this.taxon;
  72         }
  73
  74         /**
  75          *
  76          * @param taxon    taxon
  77          */
  78         public void setTaxon(Taxon taxon){
  79                 this.taxon = taxon;
  80         }
  81
  82
  83         @Transient
  84         public Calendar getIdentificationDate(){
  85                 return this.getTimeperiod().getStart();
  86         }
  87
  88         /**
  89          *
  90          * @param identificationDate    identificationDate
  91          */
  92         public void setIdentificationDate(Calendar identificationDate){
  93                 this.getTimeperiod().setStart(identificationDate);
  94         }
  95
  96         @Transient
  97         public Agent getDeterminer() {
  98                 return this.getActor();
  99         }
 100         public void setDeterminer(Agent determiner) {
 101                 this.setActor(determiner);
 102         }
 103
 104         @ManyToOne
 105         @Cascade( { CascadeType.SAVE_UPDATE })
 106         public SpecimenOrObservationBase getIdentifiedUnit() {
 107                 return identifiedUnit;
 108         }
 109
 110         public void setIdentifiedUnit(SpecimenOrObservationBase identifiedUnit) {
 111                 this.identifiedUnit = identifiedUnit;
 112         }
 113
 114         public boolean getPreferredFlag() {
 115                 return preferredFlag;
 116         }
 117
 118         public void setPreferredFlag(boolean preferredFlag) {
 119                 this.preferredFlag = preferredFlag;
 120         }
 121
 122         @Transient
 123         private static Set<ReferenceBase> getNewReferencesSet(){
 124                 return new HashSet<ReferenceBase>();
 125         }
 126
 127         @ManyToMany
 128         @Cascade( { CascadeType.SAVE_UPDATE })
 129         public Set<ReferenceBase> getReferences() {
 130                 return setOfReferences;
 131         }
 132
 133         public void setReferences(Set<ReferenceBase> references) {
 134                 this.setOfReferences = references;
 135         }
 136
 137         public void addReference(ReferenceBase reference) {
 138                 this.setOfReferences.add(reference);
 139         }
 140
 141 //*********** CLONE **********************************/
 142
 143         /**
 144          * Clones <i>this</i> determination event. This is a shortcut that enables to
 145          * create a new instance that differs only slightly from <i>this</i> determination event
 146          * by modifying only some of the attributes.<BR>
 147          * This method overrides the clone method from {@link EventBase EventBase}.
 148          *
 149          * @see EventBase#clone()
 150          * @see java.lang.Object#clone()
 151          */
 152         @Override
 153         public DeterminationEvent clone(){
 154                 try{
 155                         DeterminationEvent result = (DeterminationEvent)super.clone();
 156                         //type
 157                         result.setIdentifiedUnit(this.getIdentifiedUnit());
 158                         //modifier
 159                         result.setModifier(this.getModifier());
 160                         //taxon
 161                         result.setTaxon(this.getTaxon()); //TODO
 162                         //no changes to: preferredFlag
 163                         return result;
 164                 } catch (CloneNotSupportedException e) {
 165                         logger.warn("Object does not implement cloneable");
 166                         e.printStackTrace();
 167                         return null;
 168                 }
 169         }
 170
 171
 172
 173 }