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",

    "symbol"

@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")

    /**

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

     */

//	@XmlElement(name = "GeneralizationOf")

//    @XmlIDREF

//    @XmlSchemaType(name = "IDREF")

//	@XmlIDREF

//  @XmlSchemaType(name = "IDREF")

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

    /**

     * 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)

    @XmlElementWrapper(name = "Media")

    @XmlElement(name = "Medium")

    @XmlSchemaType(name = "IDREF")

    @XmlElement(name = "TermVocabulary")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch=FetchType.LAZY)

//  @NullOrNotEmpty

    //this term can be changed by the database instance even if the term is not managed by this instance as it is only for representation and has no semantic or identifying character

    //empty string is explicitly allowed and should be distinguished from NULL!

    private String symbol;

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

    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;

    public String getSymbol() {

        return symbol;

    }

    public void setSymbol(String symbol) {

        this.symbol = symbol;

    }

      @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;

    }

     * Gets the CDM cacher object

     */

	}

	/**

	 * Sets the CDM cacher object

	 */

	}

	public static <T extends DefinedTermBase> T getTermByClassAndUUID(Class<T> clazz, UUID uuid) {

	    if(cacher != null) {

	        Object obj = getCacher().load(uuid);

	        if(obj != null && obj.getClass().equals(clazz)) {

	            return (T)obj;

	        }

	    }

	    return null;

	}