/ - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision af45e069

Added by Andreas Müller almost 8 years ago

ID af45e069f1680a1962f3282198b8be36077b2408
Parent 77eb660c
Child 8b74112c

minor

         @ManyToOne(fetch = FetchType.LAZY)
         @XmlIDREF
         @XmlSchemaType(name="IDREF")
         @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
         @Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})
         @JoinColumn(name="specimen_id")
         @FieldBridge(impl=NotNullAwareIdBridge.class)
         //TODO maybe move down to specific classes SpecimenDescription (with Cascade.Delete) and TaxonDescription (without Cascade)

     // ****************** GETTER / SETTER **********************************/
     //	@OneToMany
     //	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     //	public Set<FeatureNode> getNodes() {
     //		return nodes;
     //	}
     //	public void setNodes(Set<FeatureNode> nodes) {
     //		this.nodes = nodes;
     //	}
     	/**
     	 * Returns the topmost {@link FeatureNode feature node} (root node) of <i>this</i>
     	 * feature tree. The root node does not have any parent. Since feature nodes
-...
     	 * @see java.lang.Object#clone()
     	 */
     	@Override
     	public Object clone() {
     		FeatureTree result;
     		try {
-...
     		return result;
+    	}
+    }

     /**
     * Copyright (C) 2007 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.model.name;
     import java.util.HashSet;
     import java.util.Set;
     import javax.persistence.Entity;
     import javax.persistence.FetchType;
     import javax.persistence.Inheritance;
     import javax.persistence.InheritanceType;
     import javax.persistence.ManyToMany;
     import javax.persistence.ManyToOne;
     import javax.xml.bind.annotation.XmlElement;
     import javax.xml.bind.annotation.XmlElementWrapper;
     import javax.xml.bind.annotation.XmlIDREF;
     import javax.xml.bind.annotation.XmlRootElement;
     import javax.xml.bind.annotation.XmlSchemaType;
     import javax.xml.bind.annotation.XmlSeeAlso;
     import javax.xml.bind.annotation.XmlType;
     import org.apache.log4j.Logger;
     import org.hibernate.annotations.Cascade;
     import org.hibernate.annotations.CascadeType;
     import org.hibernate.envers.Audited;
     import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;
     import eu.etaxonomy.cdm.model.reference.Reference;
     import eu.etaxonomy.cdm.validation.Level2;
     import eu.etaxonomy.cdm.validation.annotation.ValidTypeDesignation;
     /**
      * The (abstract) class representing a typification of one or several {@link TaxonNameBase taxon names}.<BR>
      * All taxon names which have a {@link Rank rank} "species aggregate" or lower
      * can only be typified by specimens (a {@link SpecimenTypeDesignation specimen type designation}), but taxon
      * names with a higher rank might be typified by an other taxon name with
      * rank "species" or "genus" (a {@link NameTypeDesignation name type designation}).
+     *
      * @see		TaxonNameBase
      * @see		NameTypeDesignation
      * @see		SpecimenTypeDesignation
      * @author  a.mueller
      * @created 07.08.2008
      * @version 1.0
      */
     @XmlRootElement(name = "TypeDesignationBase")
     @XmlType(name = "TypeDesignationBase", propOrder = {
         "typifiedNames",
         "notDesignated",
         "typeStatus"
     })
     @XmlSeeAlso({
         NameTypeDesignation.class,
         SpecimenTypeDesignation.class
     })
     @Entity
     @Audited
     @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
     @ValidTypeDesignation(groups=Level2.class)
     public abstract class TypeDesignationBase<T extends TypeDesignationStatusBase> extends ReferencedEntityBase implements ITypeDesignation {
         private static final long serialVersionUID = 8622351017235131355L;
         @SuppressWarnings("unused")
         private static final Logger logger = Logger.getLogger(TypeDesignationBase.class);
         @XmlElement(name = "IsNotDesignated")
         private boolean notDesignated;
         @XmlElementWrapper(name = "TypifiedNames")
         @XmlElement(name = "TypifiedName")
         @XmlIDREF
         @XmlSchemaType(name = "IDREF")
         @ManyToMany(fetch = FetchType.LAZY , mappedBy="typeDesignations")
         @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
         private Set<TaxonNameBase> typifiedNames = new HashSet<TaxonNameBase>();
     //    @XmlElement(name = "HomotypicalGroup")
     //    @XmlIDREF
     //    @XmlSchemaType(name = "IDREF")
     //    @ManyToOne(fetch = FetchType.LAZY)
     //    @Cascade(CascadeType.SAVE_UPDATE,CascadeType.MERGE)
     //    private HomotypicalGroup homotypicalGroup;
         @XmlElement(name = "TypeStatus")
         @XmlIDREF
         @XmlSchemaType(name = "IDREF")
         @ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeDesignationStatusBase.class)
         private T typeStatus;
     // **************** CONSTRUCTOR *************************************/
         /**
          * Class constructor: creates a new empty type designation.
+         *
          * @see	#TypeDesignationBase(Reference, String, String, Boolean)
          */
         protected TypeDesignationBase(){
             super();
+        }
         /**
          * Class constructor: creates a new type designation
          * (including its {@link Reference reference source} and eventually
          * the taxon name string originally used by this reference when establishing
          * the former designation).
+         *
          * @param citation				the reference source for the new designation
          * @param citationMicroReference	the string with the details describing the exact localisation within the reference
          * @param originalNameString	the taxon name string used originally in the reference source for the new designation
          * @see							#TypeDesignationBase()
          * @see							#isNotDesignated()
          * @see							TaxonNameBase#getTypeDesignations()
          */
         protected TypeDesignationBase(Reference citation, String citationMicroReference, String originalNameString) {
             this(citation, citationMicroReference, originalNameString, false);
+        }
         /**
          * Class constructor: creates a new type designation
          * (including its {@link Reference reference source} and eventually
          * the taxon name string originally used by this reference when establishing
          * the former designation).
+         *
          * @param citation				the reference source for the new designation
          * @param citationMicroReference	the string with the details describing the exact localisation within the reference
          * @param originalNameString	the taxon name string used originally in the reference source for the new designation
          * @param isNotDesignated		the boolean flag indicating whether there is no type at all for
          * 								<i>this</i> type designation
          * @see							#TypeDesignationBase()
          * @see							#isNotDesignated()
          * @see							TaxonNameBase#getTypeDesignations()
          */
         protected TypeDesignationBase(Reference citation, String citationMicroReference, String originalNameString, boolean notDesignated){
             super(citation, citationMicroReference, originalNameString);
             this.notDesignated = notDesignated;
+        }
     // **************** METHODS *************************************/
         /**
          * Returns the {@link TypeDesignationStatusBase type designation status} for <i>this</i> specimen type
          * designation. This status describes which of the possible categories of
          * types like "holotype", "neotype", "syntype" or "isotype" applies to <i>this</i>
          * specimen type designation.
          */
         public T getTypeStatus(){
             return this.typeStatus;
+        }
         /**
          * @see  #getTypeStatus()
          */
         public void setTypeStatus(T typeStatus){
             this.typeStatus = typeStatus;
+        }
     //    /* (non-Javadoc)
     //     * @see eu.etaxonomy.cdm.model.name.ITypeDesignation#getHomotypicalGroup()
     //     */
     //    /**
     //     * Returns the {@link HomotypicalGroup homotypical group} to which all (in <i>this</i>
     //     * type designation) typified {@link TaxonNameBase taxon names} belong.
     //     *
     //     * @see   #getTypifiedNames()
     //     * @deprecated homotypical group can not be set and always seems to be <code>null</code>.
     //     * Probably it is a relict of an old version.
     //     * See also http://dev.e-taxonomy.eu/trac/ticket/2173
     //     */
     //    @Deprecated
     //    public HomotypicalGroup getHomotypicalGroup() {
     //        return homotypicalGroup;
     //    }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.model.name.ITypeDesignation#getTypifiedNames()
          */
         /**
          * Returns the set of {@link TaxonNameBase taxon names} typified in <i>this</i>
          * type designation. This is a subset of the taxon names belonging to the
          * corresponding {@link #getHomotypicalGroup() homotypical group}.
          */
         @Override
         public Set<TaxonNameBase> getTypifiedNames() {
             return typifiedNames;
+        }
         /**
          * Returns the boolean value "true" if it is known that a type does not
          * exist and therefore the {@link TaxonNameBase taxon name} to which <i>this</i>
          * type designation is assigned must still be typified. Two
          * cases must be differentiated: <BR><ul>
          * <li> a) it is unknown whether a type exists and
          * <li> b) it is known that no type exists
          *  </ul>
          * If a) is true there should be no TypeDesignation instance at all
          * assigned to the "typified" taxon name.<BR>
          * If b) is true there should be a TypeDesignation instance with the
          * flag isNotDesignated set. The typeName attribute, in case of a
          * {@link NameTypeDesignation name type designation}, or the typeSpecimen attribute,
          * in case of a {@link SpecimenTypeDesignation specimen type designation}, should then be "null".
          */
         public boolean isNotDesignated() {
             return notDesignated;
+        }
         /**
          * @see   #isNotDesignated()
          */
         public void setNotDesignated(boolean notDesignated) {
             this.notDesignated = notDesignated;
+        }
         /**
          * @deprecated for bidirectional use only
          */
         @Deprecated
         protected void addTypifiedName(TaxonNameBase taxonName){
             this.typifiedNames.add(taxonName);
+        }
         /**
          * @deprecated for bidirectional use only
          */
         @Deprecated
         protected void removeTypifiedName(TaxonNameBase taxonName){
             this.typifiedNames.remove(taxonName);
             if (taxonName.getTypeDesignations().contains(this)){
                 taxonName.removeTypeDesignation(this);
+            }
+        }
         public abstract void removeType();
     //*********************** CLONE ********************************************************/
         /**
          * Clones <i>this</i> type designation. This is a shortcut that enables to create
          * a new instance that differs only slightly from <i>this</i> type designation by
          * modifying only some of the attributes.<BR>
          * CAUTION: the typifiedNames set is not cloned but empty after cloning as the typified
          * names is considered to be the not owning part of a bidirectional relationship.
          * This may be changed in future.
+         *
          * @throws CloneNotSupportedException
+         *
          * @see eu.etaxonomy.cdm.model.common.ReferencedEntityBase#clone()
          * @see java.lang.Object#clone()
          */
         @Override
         public Object clone() throws CloneNotSupportedException {
             TypeDesignationBase result = (TypeDesignationBase)super.clone();
             result.typifiedNames = new HashSet<TaxonNameBase>();
     //		for (TaxonNameBase taxonNameBase : getTypifiedNames()){
     //			result.typifiedNames.add(taxonNameBase);
     //		}
             //no changes to: notDesignated, typeStatus, homotypicalGroup
             return result;
+        }
+    }
     /**
     * Copyright (C) 2007 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.model.name;
     import java.util.HashSet;
     import java.util.Set;
     import javax.persistence.Entity;
     import javax.persistence.FetchType;
     import javax.persistence.Inheritance;
     import javax.persistence.InheritanceType;
     import javax.persistence.ManyToMany;
     import javax.persistence.ManyToOne;
     import javax.xml.bind.annotation.XmlElement;
     import javax.xml.bind.annotation.XmlElementWrapper;
     import javax.xml.bind.annotation.XmlIDREF;
     import javax.xml.bind.annotation.XmlRootElement;
     import javax.xml.bind.annotation.XmlSchemaType;
     import javax.xml.bind.annotation.XmlSeeAlso;
     import javax.xml.bind.annotation.XmlType;
     import org.apache.log4j.Logger;
     import org.hibernate.annotations.Cascade;
     import org.hibernate.annotations.CascadeType;
     import org.hibernate.envers.Audited;
     import eu.etaxonomy.cdm.model.common.ReferencedEntityBase;
     import eu.etaxonomy.cdm.model.reference.Reference;
     import eu.etaxonomy.cdm.validation.Level2;
     import eu.etaxonomy.cdm.validation.annotation.ValidTypeDesignation;
     /**
      * The (abstract) class representing a typification of one or several {@link TaxonNameBase taxon names}.<BR>
      * All taxon names which have a {@link Rank rank} "species aggregate" or lower
      * can only be typified by specimens (a {@link SpecimenTypeDesignation specimen type designation}), but taxon
      * names with a higher rank might be typified by an other taxon name with
      * rank "species" or "genus" (a {@link NameTypeDesignation name type designation}).
+     *
      * @see		TaxonNameBase
      * @see		NameTypeDesignation
      * @see		SpecimenTypeDesignation
      * @author  a.mueller
      * @created 07.08.2008
      * @version 1.0
      */
     @XmlRootElement(name = "TypeDesignationBase")
     @XmlType(name = "TypeDesignationBase", propOrder = {
         "typifiedNames",
         "notDesignated",
         "typeStatus"
     })
     @XmlSeeAlso({
         NameTypeDesignation.class,
         SpecimenTypeDesignation.class
     })
     @Entity
     @Audited
     @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
     @ValidTypeDesignation(groups=Level2.class)
     public abstract class TypeDesignationBase<T extends TypeDesignationStatusBase> extends ReferencedEntityBase implements ITypeDesignation {
         private static final long serialVersionUID = 8622351017235131355L;
         @SuppressWarnings("unused")
         private static final Logger logger = Logger.getLogger(TypeDesignationBase.class);
         @XmlElement(name = "IsNotDesignated")
         private boolean notDesignated;
         @XmlElementWrapper(name = "TypifiedNames")
         @XmlElement(name = "TypifiedName")
         @XmlIDREF
         @XmlSchemaType(name = "IDREF")
         @ManyToMany(fetch = FetchType.LAZY , mappedBy="typeDesignations")
         @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
         private Set<TaxonNameBase> typifiedNames = new HashSet<TaxonNameBase>();
         @XmlElement(name = "TypeStatus")
         @XmlIDREF
         @XmlSchemaType(name = "IDREF")
         @ManyToOne(fetch = FetchType.LAZY, targetEntity = TypeDesignationStatusBase.class)
         private T typeStatus;
     // **************** CONSTRUCTOR *************************************/
         /**
          * Class constructor: creates a new empty type designation.
+         *
          * @see	#TypeDesignationBase(Reference, String, String, Boolean)
          */
         protected TypeDesignationBase(){
             super();
+        }
         /**
          * Class constructor: creates a new type designation
          * (including its {@link Reference reference source} and eventually
          * the taxon name string originally used by this reference when establishing
          * the former designation).
+         *
          * @param citation				the reference source for the new designation
          * @param citationMicroReference	the string with the details describing the exact localisation within the reference
          * @param originalNameString	the taxon name string used originally in the reference source for the new designation
          * @see							#TypeDesignationBase()
          * @see							#isNotDesignated()
          * @see							TaxonNameBase#getTypeDesignations()
          */
         protected TypeDesignationBase(Reference citation, String citationMicroReference, String originalNameString) {
             this(citation, citationMicroReference, originalNameString, false);
+        }
         /**
          * Class constructor: creates a new type designation
          * (including its {@link Reference reference source} and eventually
          * the taxon name string originally used by this reference when establishing
          * the former designation).
+         *
          * @param citation				the reference source for the new designation
          * @param citationMicroReference	the string with the details describing the exact localisation within the reference
          * @param originalNameString	the taxon name string used originally in the reference source for the new designation
          * @param isNotDesignated		the boolean flag indicating whether there is no type at all for
          * 								<i>this</i> type designation
          * @see							#TypeDesignationBase()
          * @see							#isNotDesignated()
          * @see							TaxonNameBase#getTypeDesignations()
          */
         protected TypeDesignationBase(Reference citation, String citationMicroReference, String originalNameString, boolean notDesignated){
             super(citation, citationMicroReference, originalNameString);
             this.notDesignated = notDesignated;
+        }
     // **************** METHODS *************************************/
         /**
          * Returns the {@link TypeDesignationStatusBase type designation status} for <i>this</i> specimen type
          * designation. This status describes which of the possible categories of
          * types like "holotype", "neotype", "syntype" or "isotype" applies to <i>this</i>
          * specimen type designation.
          */
         public T getTypeStatus(){
             return this.typeStatus;
+        }
         /**
          * @see  #getTypeStatus()
          */
         public void setTypeStatus(T typeStatus){
             this.typeStatus = typeStatus;
+        }
         /**
          * Returns the set of {@link TaxonNameBase taxon names} typified in <i>this</i>
          * type designation. This is a subset of the taxon names belonging to the
          * corresponding {@link #getHomotypicalGroup() homotypical group}.
          */
         @Override
         public Set<TaxonNameBase> getTypifiedNames() {
             return typifiedNames;
+        }
         /**
          * Returns the boolean value "true" if it is known that a type does not
          * exist and therefore the {@link TaxonNameBase taxon name} to which <i>this</i>
          * type designation is assigned must still be typified. Two
          * cases must be differentiated: <BR><ul>
          * <li> a) it is unknown whether a type exists and
          * <li> b) it is known that no type exists
          *  </ul>
          * If a) is true there should be no TypeDesignation instance at all
          * assigned to the "typified" taxon name.<BR>
          * If b) is true there should be a TypeDesignation instance with the
          * flag isNotDesignated set. The typeName attribute, in case of a
          * {@link NameTypeDesignation name type designation}, or the typeSpecimen attribute,
          * in case of a {@link SpecimenTypeDesignation specimen type designation}, should then be "null".
          */
         public boolean isNotDesignated() {
             return notDesignated;
+        }
         /**
          * @see   #isNotDesignated()
          */
         public void setNotDesignated(boolean notDesignated) {
             this.notDesignated = notDesignated;
+        }
         /**
          * @deprecated for bidirectional use only
          */
         @Deprecated
         protected void addTypifiedName(TaxonNameBase taxonName){
             this.typifiedNames.add(taxonName);
+        }
         /**
          * @deprecated for bidirectional use only
          */
         @Deprecated
         protected void removeTypifiedName(TaxonNameBase taxonName){
             this.typifiedNames.remove(taxonName);
             if (taxonName.getTypeDesignations().contains(this)){
                 taxonName.removeTypeDesignation(this);
+            }
+        }
         public abstract void removeType();
     //*********************** CLONE ********************************************************/
         /**
          * Clones <i>this</i> type designation. This is a shortcut that enables to create
          * a new instance that differs only slightly from <i>this</i> type designation by
          * modifying only some of the attributes.<BR>
          * CAUTION: the typifiedNames set is not cloned but empty after cloning as the typified
          * names is considered to be the not owning part of a bidirectional relationship.
          * This may be changed in future.
+         *
          * @throws CloneNotSupportedException
+         *
          * @see eu.etaxonomy.cdm.model.common.ReferencedEntityBase#clone()
          * @see java.lang.Object#clone()
          */
         @Override
         public Object clone() throws CloneNotSupportedException {
             TypeDesignationBase result = (TypeDesignationBase)super.clone();
             result.typifiedNames = new HashSet<TaxonNameBase>();
     //		for (TaxonNameBase taxonNameBase : getTypifiedNames()){
     //			result.typifiedNames.add(taxonNameBase);
     //		}
             //no changes to: notDesignated, typeStatus, homotypicalGroup
             return result;
+        }
+    }

     //    @IndexedEmbedded
         @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
        // @InReference(groups=Level2.class)
        	protected Reference<?> inReference;
     //    @XmlElement(name = "FullReference")
     //    @XmlIDREF
     //    @XmlSchemaType(name = "IDREF")
     //    @ManyToOne(fetch = FetchType.LAZY)
     ////    @IndexedEmbedded
     //    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     //    protected Reference fullReference;
     //
     //    @XmlElement(name = "AbbreviatedReference")
     //    @XmlIDREF
     //    @XmlSchemaType(name = "IDREF")
     //    @ManyToOne(fetch = FetchType.LAZY)
     ////    @IndexedEmbedded
     //    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     //    protected Reference abbreviatedReference;
     //********************************************************/
     	//The date range assigned to the reference. ISO Date range like. Flexible, year can be left out, etc
-...
     	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     	private TeamOrPersonBase<?> authorship;
     //	@XmlElement(name = "ReferenceIdentity")
     //	@XmlIDREF
     //	@XmlSchemaType(name = "IDREF")
     //	@ManyToOne(fetch = FetchType.LAZY)
     //	//@IndexedEmbedded
     //	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     //	@Transient
     //	private ReferenceIdentity referenceIdentity;
     	@XmlAttribute
         @Match(MatchMode.IGNORE)
     	private int parsingProblem = 0;
-...
     		this.editor = StringUtils.isBlank(editor)? null : editor;
+    	}
     //	@Override
     //    public String getSeries() {
     //		return series;
     //	}
     //
     //	@Override
     //    public void setSeries(String series) {
     //		this.series = series;
     //	}
     	@Override
         public String getVolume() {
     		return volume;
-...
     	@Override
         public void setType(ReferenceType type) {
     		this.setCacheStrategy(type.getCacheStrategy());
     		if (type == null){
     			this.type = ReferenceType.Generic;
     		} else{
     			this.type = type;
+    		}
     		this.setCacheStrategy(type.getCacheStrategy());
+    	}
-...
+    	}
     	/**
     	 * Returns "true" if the isNomenclaturallyRelevant flag is set. This
     	 * indicates that a {@link TaxonNameBase taxon name} has been originally
-...
+    	}
     //	/**
     //	 * Returns the full reference that belongs to this abbreviated reference. If this
     //	 * reference is not abbreviated the full reference should be <code>null</code>.<BR>
     //	 * A full reference should be added to a reference
     //	 * which represents the abbreviated form of a reference. The full reference can be used
     //	 * by publication tools to link to the unabbreviated and therefore more complete version
     //	 * of the reference.
     //	 *
     //	 * @see #getAbbreviatedReference()
     //	 * @return the full reference
     //	 */
     //	public Reference getFullReference() {
     //		return fullReference;
     //	}
     //
     //	/**
     //	 * @see #getFullReference()
     //	 * @param fullReference
     //	 */
     //	public void setFullReference(Reference fullReference) {
     //		this.fullReference = fullReference;
     //	}
     //
     //	/**
     //	 * Returns the abbreviated reference that belongs to this full reference. If this
     //	 * reference is not a full reference the abbeviated referece must be <code>null</code>.<BR>
     //	 * An abbreviated reference should be added to a reference which represents the long (full)
     //	 * form of a reference.
     //	 * In future this may become a set or handled differently as there are multiple
     //	 *
     //	 * @see #getFullReference()
     //	 * @return the full reference
     //	 */
     //	public Reference getAbbreviatedReference() {
     //		return abbreviatedReference;
     //	}
     //
     //	/**
     //	 * @see #getAbbreviatedReference()
     //	 * @param abbreviatedReference
     //	 *
     //	 */
     //	public void setAbbreviatedReference(Reference abbreviatedReference) {
     //		this.abbreviatedReference = abbreviatedReference;
     //	}
     //****************************************************  /
     //	/**
     //	 * Returns the string representing the name of the editor of <i>this</i>
     //	 * generic reference. An editor is mostly a person (team) who assumed the
     //	 * responsibility for the content of the publication as a whole without
     //	 * being the author of this content.<BR>
     //	 * If there is an editor then the generic reference must be some
     //	 * kind of {@link PrintedUnitBase physical printed unit}.
     //	 *
     //	 * @return  the string identifying the editor of <i>this</i>
     //	 * 			generic reference
     //	 * @see 	#getPublisher()
     //	 */
     //	protected String getEditor(){
     //		return this.editor;
     //	}
     //
     //	/**
     //	 * @see #getEditor()
     //	 */
     //	protected void setEditor(String editor){
     //		this.editor = editor;
     //	}
     //
     //	/**
     //	 * Returns the string representing the series (for instance for books or
     //	 * within journals) - and series part - in which <i>this</i> generic reference
     //	 * was published.<BR>
     //	 * If there is a series then the generic reference must be some
     //	 * kind of {@link PrintedUnitBase physical printed unit} or an {@link Article article}.
     //	 *
     //	 * @return  the string identifying the series for <i>this</i>
     //	 * 			generic reference
     //	 */
     //	protected String getSeries(){
     //		return this.series;
     //	}
     //
     //	/**
     //	 * @see #getSeries()
     //	 */
     //	protected void setSeries(String series){
     //		this.series = series;
     //	}
     //
     //	/**
     //	 * Returns the string representing the volume (for instance for books or
     //	 * within journals) in which <i>this</i> generic reference was published.<BR>
     //	 * If there is a volume then the generic reference must be some
     //	 * kind of {@link PrintedUnitBase physical printed unit} or an {@link Article article}.
     //	 *
     //	 * @return  the string identifying the volume for <i>this</i>
     //	 * 			generic reference
     //	 */
     //	protected String getVolume(){
     //		return this.volume;
     //	}
     //
     //	/**
     //	 * @see #getVolume()
     //	 */
     //	protected void setVolume(String volume){
     //		this.volume = volume;
     //	}
     //
     //	/**
     //	 * Returns the string representing the page(s) where the content of
     //	 * <i>this</i> generic reference is located.<BR>
     //	 * If there is a pages information then the generic reference must be some
     //	 * kind of {@link PrintedUnitBase physical printed unit} or an {@link Article article}.
     //	 *
     //	 * @return  the string containing the pages corresponding to <i>this</i>
     //	 * 			generic reference
     //	 */
     //	protected String getPages(){
     //		return this.pages;
     //	}
     //
     //	/**
     //	 * @see #getPages()
     //	 */
     //	protected void setPages(String pages){
     //		this.pages = pages;
     //	}
     	/**
     	 * Returns a formatted string containing the entire reference citation,
-...
     //	/**
     //	 * Returns the reference identity object
     //	 * @return the referenceIdentity
     //	 */
     //	public ReferenceIdentity getReferenceIdentity() {
     //		return referenceIdentity;
     //	}
     //
     //	/**
     //	 * For bidirectional use only
     //	 * @param referenceIdentity the referenceIdentity to set
     //	 */
     //	protected void setReferenceIdentity(ReferenceIdentity referenceIdentity) {
     //		this.referenceIdentity = referenceIdentity;
     //	}
     //
     //	/**
     //	 * Returns the set of all identical references. Same as getReferenceIdentity().getReferences()
     //	 * @return
     //	 */
     //	public Set<Reference> identicalReferences(){
     //		return referenceIdentity.getReferences();
     //	}
     //********** Casting methods ***********************************/
     	/**
-...
+    	}
     	//public void setCacheStrategy(S cacheStrategy){
     	//	this.cacheStrategy = cacheStrategy;
     	//}
     	@Override
         public void setCacheStrategy(IReferenceBaseCacheStrategy iReferenceBaseCacheStrategy) {
     		this.cacheStrategy = (S) iReferenceBaseCacheStrategy;

     // $Id$
     /**
     * Copyright (C) 2007 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     // NOT YET IN USE //
     package eu.etaxonomy.cdm.model.reference;
     import java.util.Set;
     import javax.persistence.FetchType;
     import javax.persistence.ManyToOne;
     import javax.persistence.OneToMany;
     import javax.xml.bind.annotation.XmlAccessType;
     import javax.xml.bind.annotation.XmlAccessorType;
     import javax.xml.bind.annotation.XmlElement;
     import javax.xml.bind.annotation.XmlElementWrapper;
     import javax.xml.bind.annotation.XmlIDREF;
     import javax.xml.bind.annotation.XmlSchemaType;
     import javax.xml.bind.annotation.XmlType;
     import org.apache.log4j.Logger;
     import org.hibernate.annotations.Cascade;
     import org.hibernate.annotations.CascadeType;
     import org.hibernate.envers.Audited;
     import eu.etaxonomy.cdm.model.common.VersionableEntity;
     /**
      * @author a.mueller
      * @created 30.06.2009
      * @version 1.0
      */
     @XmlAccessorType(XmlAccessType.FIELD)
     @XmlType(name = "ReferenceIdentity", propOrder = {
     	"preferredLongForm",
     	"preferredAbbreviation",
         "references"
     })
     @Audited
     //@Entity
     public class ReferenceIdentity extends VersionableEntity {
     	private static final long serialVersionUID = -6114973116800471106L;
     	@SuppressWarnings("unused")
     	private static final Logger logger = Logger.getLogger(ReferenceIdentity.class);
     	@XmlElementWrapper(name = "References")
         @XmlElement(name = "Reference")
         @XmlIDREF
         @XmlSchemaType(name = "IDREF")
         @OneToMany(mappedBy="name", fetch= FetchType.LAZY)
     	private Set<Reference> references;
     	@XmlElement(name = "PreferredLongForm")
     	@XmlIDREF
     	@XmlSchemaType(name = "IDREF")
     	@ManyToOne(fetch = FetchType.LAZY)
     	//@IndexedEmbedded
     	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     	private Reference preferredLongForm;
     	@XmlElement(name = "PreferredAbbreviation")
     	@XmlIDREF
     	@XmlSchemaType(name = "IDREF")
     	@ManyToOne(fetch = FetchType.LAZY)
     	//@IndexedEmbedded
     	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
     	private Reference preferredAbbreviation;
     	/**
     	 * @return the references
     	 */
     	public Set<Reference> getReferences() {
     		return references;
+    	}
     //	/**
     //	 * Adds the reference to this reference identity
     //	 * @param reference
     //	 * @return
     //	 */
     //	public boolean addReference(Reference reference){
     //		if (reference == null){
     //			return false;
     //		}
     //		if (reference.getReferenceIdentity() != null){
     //			reference.setReferenceIdentity(this);
     //		}
     //		return this.references.add(reference);
     //	}
     //
     //	public boolean removeReference(Reference reference){
     //		if (reference == null){
     //			return false;
     //		}
     //		reference.setReferenceIdentity(null);
     //		return this.references.remove(reference);
     //	}
     	/**
     	 * @return the preferredLongForm
     	 */
     	public Reference getPreferredLongForm() {
     		return preferredLongForm;
+    	}
     	/**
     	 * @param preferredLongForm the preferredLongForm to set
     	 */
     	public void setPreferredLongForm(Reference preferredLongForm) {
     		this.preferredLongForm = preferredLongForm;
+    	}
     	/**
     	 * @return the preferredAbbreviation
     	 */
     	public Reference getPreferredAbbreviation() {
     		return preferredAbbreviation;
+    	}
     	/**
     	 * @param preferredAbbreviation the preferredAbbreviation to set
     	 */
     	public void setPreferredAbbreviation(Reference preferredAbbreviation) {
     		this.preferredAbbreviation = preferredAbbreviation;
+    	}
+    }

Also available in: Unified diff

Project

General

Profile

EDIT

Revision af45e069

Added by Andreas Müller almost 8 years ago