EDIT

/**

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.model.common;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import javax.persistence.FetchType;

import javax.persistence.Inheritance;

import javax.persistence.InheritanceType;

import javax.persistence.OneToMany;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlTransient;

import org.hibernate.annotations.CascadeType;

import org.hibernate.envers.Audited;

import org.hibernate.proxy.LazyInitializer;

import au.com.bytecode.opencsv.CSVWriter;

import eu.etaxonomy.cdm.model.description.MeasurementUnit;

import eu.etaxonomy.cdm.model.description.StatisticalMeasure;

import eu.etaxonomy.cdm.model.description.TextFormat;

import eu.etaxonomy.cdm.model.location.NamedAreaType;

import eu.etaxonomy.cdm.model.location.ReferenceSystem;

import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;

import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;

 * be BreadthFirst (not DepthFirst)

 * @author m.doering

 * @created 08-Nov-2007 13:06:19

 */

@XmlType(name = "DefinedTermBase", propOrder = {

    "media",

    "idInVocabulary"

@XmlRootElement(name = "DefinedTermBase")

    DerivationEventType.class,

    Language.class,

    MarkerType.class,

    MeasurementUnit.class,

    NamedAreaType.class,

    NomenclaturalCode.class,

    PreservationMethod.class,

    ReferenceSystem.class,

public abstract class DefinedTermBase<T extends DefinedTermBase> extends TermBase implements ILoadableTerm<T>, IDefinedTerm<T>, Comparable<T> {

    private static final Logger logger = Logger.getLogger(DefinedTermBase.class);

//    @XmlIDREF

//    @XmlSchemaType(name = "IDREF")

    @Cascade(CascadeType.SAVE_UPDATE)

    /**

     * Hibernate.initialize(), does this imply a distinct load, and find methods in the dao?

     */

//	@XmlElement(name = "GeneralizationOf")

//    @XmlIDREF

//    @XmlSchemaType(name = "IDREF")

    private Set<T> generalizationOf = new HashSet<T>();

//	@XmlIDREF

//  @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY, targetEntity = DefinedTermBase.class)

    @Cascade(CascadeType.SAVE_UPDATE)

    protected T partOf;

    /**

     * FIXME - Hibernate retuns this as a collection of CGLibProxy$$DefinedTermBase objects

     * which can't be cast to instances of T - can we explicitly initialize these terms using

     * Hibernate.initialize(), does this imply a distinct load, and find methods in the dao?

     */

//	@XmlElement(name = "Include")

//	@XmlIDREF

//    @XmlSchemaType(name = "IDREF")

    @OneToMany(fetch=FetchType.LAZY, mappedBy = "partOf", targetEntity = DefinedTermBase.class)

    @Cascade({CascadeType.SAVE_UPDATE})

    private Set<T> includes = new HashSet<T>();

    @XmlElementWrapper(name = "Media")

    @XmlElement(name = "Medium")

    @XmlSchemaType(name = "IDREF")

    private Set<Media> media = new HashSet<Media>();

    @XmlElement(name = "TermVocabulary")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch=FetchType.LAZY)

    @Cascade(CascadeType.SAVE_UPDATE)

    protected TermVocabulary<T> vocabulary;

//  @NullOrNotEmpty

//***************************** CONSTRUCTOR *******************************************/

	//for javassit only

    protected DefinedTermBase(){};

        super(type);

        super(type, description, label, labelAbbrev);

      @Override

      public String getIdInVocabulary() {

          return idInVocabulary;

      }

      @Override

      public void setIdInVocabulary(String idInVocabulary) {

      @Override

          if (this instanceof HibernateProxy) {

              HibernateProxy proxy = (HibernateProxy) this;

              LazyInitializer li = proxy.getHibernateLazyInitializer();

              return (T) ((T)li.getImplementation()).getKindOf();

          } else {

              return (T)DefinedTermBase.deproxy(this.kindOf, this.getClass());

          }

      public void setKindOf(T kindOf){

          this.kindOf = kindOf;

      }

      @Override

          return this.generalizationOf;

      }

      protected void setGeneralizationOf(Set<T> value) {

          this.generalizationOf = value;

      }

      public void addGeneralizationOf(T generalization) {

          generalization.setKindOf(this);

          this.generalizationOf.add(generalization);

      }

          if(generalizationOf.contains(generalization)){

              generalization.setKindOf(null);

              this.generalizationOf.remove(generalization);

          }

      }

              HibernateProxy proxy = (HibernateProxy) this;

              LazyInitializer li = proxy.getHibernateLazyInitializer();

              return (T) ((T)li.getImplementation()).getPartOf();

          } else {

              return (T)DefinedTermBase.deproxy(this.partOf, this.getClass());

          }

       * @see #getPartOf()

      */

          this.partOf = partOf;

      }

  	@Override

  	@Deprecated //for inner use only

  	public int compareTo(T other) {

		return ((Integer)this.getId()).compareTo(other.getId());

	}

	@Override

          return this.includes;

      }

       * @see #getIncludes()

      */

          this.includes = includes;

      }

       * @see #getIncludes()

      public void addIncludes(T includes) {

          includes.setPartOf(this);

          this.includes.add(includes);

      }

       * @see #getIncludes()

      public void removeIncludes(T includes) {

          if(this.includes.contains(includes)) {

              includes.setPartOf(null);

              this.includes.remove(includes);

          }

      }

          return this.media;

      }

      public void addMedia(Media media) {

          this.media.add(media);

      }

      public void removeMedia(Media media) {

          this.media.remove(media);

      }

      /**

       * @return

       */

      public TermVocabulary<T> getVocabulary() {

          return this.vocabulary;

      }

      //for bedirectional use only, use vocabulary.addTerm instead

      /**

       * @param newVocabulary

       */

      protected void setVocabulary(TermVocabulary<T> newVocabulary) {

          this.vocabulary = newVocabulary;

//******************************* METHODS ******************************************************/

      @Override

      public boolean isKindOf(T ancestor) {

          if (kindOf == null || ancestor == null){

            return false;

        }else if (kindOf.equals(ancestor)){

            return true;

        }else{

            return kindOf.isKindOf(ancestor);

        }

      }

      @Override

      public Set<T> getGeneralizationOf(boolean recursive) {

          Set<T> result = new HashSet<T>();

        result.addAll(this.generalizationOf);

        if (recursive){

            for (T child : this.generalizationOf){

                result.addAll(child.getGeneralizationOf());

            }

        }

        return result;

      }

    protected abstract void setDefaultTerms(TermVocabulary<T> termVocabulary);

    public T readCsvLine(Class<T> termClass, List<String> csvLine, Map<UUID,DefinedTermBase> terms, boolean abbrevAsId) {

            readIsPartOf(newInstance, csvLine, terms);

            return newInstance;

            logger.error(e);

            for(StackTraceElement ste : e.getStackTrace()) {

                logger.error(ste);

            }

    }

    protected static <TERM extends DefinedTermBase> TERM readCsvLine(TERM newInstance, List<String> csvLine, Language lang, boolean abbrevAsId) {

        newInstance.setUri( URI.create(csvLine.get(1)));

        String label = csvLine.get(2).trim();

        String description = csvLine.get(3);

        String abbreviatedLabel = csvLine.get(4);

        if (StringUtils.isBlank(abbreviatedLabel)){

        if (abbrevAsId){

        newInstance.addRepresentation(Representation.NewInstance(description, label, abbreviatedLabel, lang) );

    }

        int index = partOfCsvLineIndex();

            String partOfString = csvLine.get(index);

             if(StringUtils.isNotBlank(partOfString)) {

                 UUID partOfUuid = UUID.fromString(partOfString);

                 DefinedTermBase partOf = terms.get(partOfUuid);

                 partOf.addIncludes(newInstance);

             }

         }

    }

    /**

     * Get the

     * @return

     */

    protected int partOfCsvLineIndex() {

        return -1;

    }

    private  <T extends DefinedTermBase> T getInstance(Class<? extends DefinedTermBase> termClass) {

        try {

            Constructor<T> c = ((Class<T>)termClass).getDeclaredConstructor();

            c.setAccessible(true);

            T termInstance = c.newInstance();

            return termInstance;

        } catch (Exception e) {

            throw new RuntimeException(e);

        }

        String [] line = new String[4];

        line[0] = term.getUuid().toString();

        line[1] = term.getUri().toString();

        line[2] = term.getLabel();

        line[3] = term.getDescription();

        writer.writeNext(line);

    }

    @Transient

    public T getByUuid(UUID uuid){

        return this.vocabulary.findTermByUuid(uuid);

    }

    /**

     * Clones <i>this</i> DefinedTermBase. This is a shortcut that enables to create

     * a new instance that differs only slightly from <i>this</i> defined term base by

     * modifying only some of the attributes.

     *

     * @see eu.etaxonomy.cdm.model.common.TermBase#clone()

     * @see java.lang.Object#clone()

     */

    @Override

    public Object clone() {

        DefinedTermBase result;

        try {

            result = (DefinedTermBase) super.clone();

        }catch (CloneNotSupportedException e) {

            logger.warn("Object does not implement cloneable");

            e.printStackTrace();

            return null;

        }

        result.generalizationOf = new HashSet<DefinedTermBase>();

        for (DefinedTermBase generalizationOf : this.generalizationOf){

        result.includes = new HashSet<DefinedTermBase>();

        for (DefinedTermBase include: this.includes){

        result.media = new HashSet<Media>();

        for (Media media: this.media){

            result.addMedia(media);

        }

        return result;

    }

    private static ICdmCacher cacher;

     * Gets the CDM cacher object

     */

    public static ICdmCacher getCacher() {

		return cacher;

	}

	/**

	 * Sets the CDM cacher object

	 */

	public static void setCacher(ICdmCacher cacher) {

		DefinedTermBase.cacher = cacher;

	}