EDIT

            if (rel.getType()!= null && rel.getType().isBasionymRelation()){

                TaxonNameBase<?,?> basionym = rel.getFromName();

/**

* 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.taxon;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Set;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.model.name.NameRelationship;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

/**

 * This class orders synonyms of a homotypic group,

 * first by

 * <ul>

 *  <li>Basionym groups (the basionym and all names derived from this basionym)

 *      should be kept together in a subgroup</li>

 *  <li>The order of the subgroups is defined by the ordering of their

 *       basionyms (according to the following ordering)</li>

 *  <li>If a name is illegitimate or not does play a role for ordering</li>

 *  <li>Names with publication year should always come first</li>

 *  <li>Names with no publication year are sorted alphabetically</li>

 *  <li>If 2 names have a replaced synonym relationship the replaced synonym comes first,

 *      the replacement name comes later as this reflects the order of publication</li>

 *  </ul>

 *

 * Details on ordering are explained at http://dev.e-taxonomy.eu/trac/ticket/3338<BR>

 *

 * @author a.mueller

 * @created 02.03.2016

 */

public class HomotypicGroupTaxonComparator extends TaxonComparator {

    private static final long serialVersionUID = -5088210641256430878L;

    @SuppressWarnings("unused")

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

    private final TaxonBase<?> firstTaxonInGroup;

    private final TaxonNameBase<?,?> firstNameInGroup;

    /**

     * @param firstNameInGroup

     */

    public HomotypicGroupTaxonComparator(@SuppressWarnings("rawtypes") TaxonBase firstTaxonInGroup) {

        this.firstTaxonInGroup = firstTaxonInGroup;

        this.firstNameInGroup = firstTaxonInGroup == null ? null: firstTaxonInGroup.getName();

    }

    /**

     *

     * @see TaxonComparator#compare(TaxonBase, TaxonBase)

     * @see java.lang.String#compareTo(String)

     * @see	java.util.Comparator#compare(java.lang.Object, java.lang.Object)

     */

    @Override

    public int compare(

            @SuppressWarnings("rawtypes") TaxonBase taxonBase1,

            @SuppressWarnings("rawtypes") TaxonBase taxonBase2) {

        TaxonNameBase<?,?> name1 = taxonBase1.getName();

        TaxonNameBase<?,?> name2 = taxonBase2.getName();

        System.out.print(name1.getTitleCache() +" : "+ name2.getTitleCache());

        int compareStatus = compareStatus(name1, name2);

        if (compareStatus != 0){

            return compareStatus;

        }

        //not same homotypical group -

        //NOTE: this comparator should usually not be used

        //      for comparing names of different homotypcial groups.

        //      The following is only to have a defined compare behavior

        //      which follows the contract of Comparator#compare.

        if (name1 == null ||

            name2 == null ||

            ! name1.getHomotypicalGroup().equals(name2.getHomotypicalGroup())){

            int result = name1.getHomotypicalGroup().getUuid().toString()

                    .compareTo(name2.getHomotypicalGroup().getUuid().toString());

            System.out.println(": t" + result);

            System.out.println(name1.getHomotypicalGroup().getUuid());

            System.out.println(name2.getHomotypicalGroup().getUuid());

            return result;

        }

        //same homotypical group ...

        //one taxon is first in group

        if (taxonBase1.equals(firstTaxonInGroup)){

            return -1;

        }else if (taxonBase2.equals(firstTaxonInGroup)){

            return 1;

        }

        System.out.print("_");

        //same name => compare on taxon level

        if (name1.equals(name2)){

            return super.compare(taxonBase1, taxonBase2);  //if name is the same compare on taxon level

        }

        System.out.print("_");

        TaxonNameBase<?,?> basionym1 = getPreferredInBasionymGroup(name1);

        TaxonNameBase<?,?> basionym2 = getPreferredInBasionymGroup(name2);

        int compareResult;

        if (basionym1.equals(basionym2)){

            //both names belong to same basionym sub-group

            compareResult = handleSameBasionym(basionym1, name1, name2);

        }else{

            compareResult = compareBasionyms(basionym1, basionym2);

        }

        if (compareResult != 0){

            System.out.println(": " + compareResult);

            return compareResult;

        }else{

            //names are uncomparable on name level (except for uuid, id, etc.)

            int result = super.compare(taxonBase1, taxonBase2);

            System.out.println(": = " + result);

            return result;

        }

    }

//    /**

//     * @param homotypicalGroup

//     * @return

//     */

//    private TaxonBase<?> getFirstInHomotypicalGroup(HomotypicalGroup homotypicalGroup, Collection<TaxonBase<?>> existing) {

//        List<TaxonBase<?>> candidates =  new ArrayList<TaxonBase<?>>();

//        for (TaxonBase<?> candidate : existing){

//            if (homotypicalGroup.getTypifiedNames().contains(candidate.getName())){

//                candidates.add(candidate);

//            }

//        }

//        Collections.sort(candidates, this);

//        return candidates.isEmpty() ? null : candidates.get(0);

//    }

    /**

     * Compare 2 names which have the same basionym.

     * The names must not be equal to each other but may be equal

     * to the basionym.

     * @param basionym the basionym

     * @param name1 first name to compare

     * @param name2 second name to compare

     * @return compare value according to the {@link Comparator#compare(Object, Object)} contract.

     */

    private int handleSameBasionym(TaxonNameBase<?, ?> basionym,

            TaxonNameBase<?, ?> name1,

            TaxonNameBase<?, ?> name2) {

        if (basionym.equals(name1)){

            return -1;

        }else if (basionym.equals(name2)){

            return 1;

        }else{

            super.compare(name1, name2);

        }

        return 0;

    }

    /**

     * @param basionym1

     * @param basionym2

     * @return

     */

    private int compareBasionyms(TaxonNameBase<?,?> basionym1Orig, TaxonNameBase<?,?> basionym2Orig) {

        //one taxon is first in group

        TaxonNameBase<?,?> basionym1 = getFirstNameInGroup(basionym1Orig);

        TaxonNameBase<?,?> basionym2 = getFirstNameInGroup(basionym2Orig);

        if (basionym1.equals(firstNameInGroup)){

            return -1;

        }else if (basionym2.equals(firstTaxonInGroup)){

            return 1;

        }

        if (getReplacedSynonymClosure(basionym1).contains(basionym2)){

            return 1;

        }else if (getReplacedSynonymClosure(basionym2).contains(basionym1)){

            return -1;

        }

        int result = super.compare(basionym1, basionym2);

        return result;

    }

    /**

     * @param basionym

     * @return

     */

    private TaxonNameBase<?, ?> getFirstNameInGroup(TaxonNameBase<?, ?> basionym) {

        for (NameRelationship nameRel : basionym.getRelationsFromThisName()){

            if (nameRel.getType() != null && nameRel.getType().equals(NameRelationshipType.BASIONYM())){

                if (nameRel.getToName().equals(firstNameInGroup)){

                    return firstNameInGroup;

                }

            }

        }

        return basionym;

    }

    /**

     * @param basionym1

     * @return

     */

    @SuppressWarnings("rawtypes")

    private Set<TaxonNameBase> getReplacedSynonymClosure(TaxonNameBase<?, ?> name) {

        Set<TaxonNameBase> set = name.getReplacedSynonyms();

        if (set.isEmpty()){

            return set;

        }

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

        for (TaxonNameBase<?,?> replSyn : set){

            boolean notYetContained = result.add(replSyn);

            if (notYetContained){

                result.addAll(replSyn.getReplacedSynonyms());

            }

        }

        return result;

    }

    /**

     * @param name1

     * @return

     */

    private TaxonNameBase<?,?> getPreferredInBasionymGroup(TaxonNameBase<?,?> name) {

        HashMap<UUID, TaxonNameBase<?,?>> candidates = new HashMap<UUID, TaxonNameBase<?,?>>();

        for (TaxonNameBase<?,?> candidate : name.getBasionyms()){

            if (candidate != null && candidate.getHomotypicalGroup().equals(name.getHomotypicalGroup())){

                candidates.put(candidate.getUuid(), candidate);

            }

        }

        if (candidates.isEmpty()){

            return name;

        }else{

            return candidates.get(candidates.keySet().iterator().next());

        }

    }

}

        return getSynonymsInGroup(homotypicGroup, new TaxonComparator());

    }

    /**

     * @param homotypicGroup

     * @param comparator

     * @return

     * @see {@link #getSynonymsInGroup(HomotypicalGroup)}

     */

    @Transient

    public List<Synonym> getSynonymsInGroup(HomotypicalGroup homotypicGroup, TaxonComparator comparator){

        Collections.sort(result, comparator);

/**

* 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.taxon;

import java.io.Serializable;

import java.util.Comparator;

import java.util.Set;

import org.apache.log4j.Logger;

import org.joda.time.DateTime;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.name.ZoologicalName;

import eu.etaxonomy.cdm.model.reference.Reference;

/**

 * This class makes available a method to compare two {@link TaxonBase taxa} by

 * comparing the publication dates of the corresponding

 * {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon names}.

 *

 * @author a.mueller

 * @created 11.06.2008

 */

public class TaxonComparator implements Comparator<TaxonBase>, Serializable {

	private static final long serialVersionUID = -1433623743189043446L;

	@SuppressWarnings("unused")

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

    /**

     * Returns an integer generated by comparing first the nomenclatural status and then the

     * {@link eu.etaxonomy.cdm.model.name.INomenclaturalReference#getYear() publication years}

     * of both {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon names}

     * used in the given {@link TaxonBase taxa}.

     * If 1 name has status of type nom. inval. or nom. nudum the name is put to the end of a

     * list (returns +1 for a status in taxon1 and -1 for a status in taxon2). If both do have

     * no status or the same status, the publication date is taken for comparison.

     * Nom. nudum is handled as more "severe" status then nom.inval.

     *

     * Returns a negative value if the publication year corresponding to the

     * first given taxon precedes the publication year corresponding to the

     * second given taxon. Returns a positive value if the contrary is true and

     * 0 if both publication years and the date, when they are created, are identical.

     * In case one of the publication

     * years is "null" and the other is not, the "empty" publication year will

     * be considered to be always preceded by the "not null" publication year.

     * If both publication years are "null" the creation date is used for the comparison

     *

     *

     * @see		java.lang.String#compareTo(String)

     * @see		java.util.Comparator#compare(java.lang.Object, java.lang.Object)

     */

    @Override

    public int compare(

            @SuppressWarnings("rawtypes") TaxonBase taxonBase1,

            @SuppressWarnings("rawtypes") TaxonBase taxonBase2) {

        int result;

        if (taxonBase1.equals(taxonBase2)){

        	return 0;

        }

        TaxonNameBase<?,?> name1 = taxonBase1.getName();

        TaxonNameBase<?,?> name2 = taxonBase2.getName();

        //set to end if a taxon has nomenclatural status "nom. inval." or "nom. nud."

        int statusCompareWeight = compareStatus(name1, name2);

        if (statusCompareWeight != 0){

        	return Integer.signum(statusCompareWeight);

        }

        result = compare(name1, name2);

        if (result == 0){

            DateTime date11 = taxonBase1.getCreated();

            DateTime date12 = taxonBase2.getCreated();

            if (date11 == null && date12 == null) {

                result = 0;

            }else if (date11 == null) {

                return 1;

            }else if (date12 == null) {

                return -1;

            }else{

            	result = date11.compareTo(date12);

            }

        }

        if (result == 0){

        	//the Comparator contract

        	return taxonBase1.getUuid().compareTo(taxonBase1.getUuid());

        }else{

        	return result;

        }

    }

    /**

     * @param taxonNameBase

     * @param taxonNameBase2

     * @param statusCompareWeight

     * @return

     */

    protected int compareStatus(TaxonNameBase<?,?> taxonNameBase, TaxonNameBase<?,?> taxonNameBase2) {

        int statusCompareWeight = 0;

        statusCompareWeight += computeStatusCompareWeight(taxonNameBase);

        statusCompareWeight -= computeStatusCompareWeight(taxonNameBase2);

        return statusCompareWeight;

    }

	/**

	 * @param taxonBase1

	 * @param statusCompareWeight

	 * @return

	 */

	private int computeStatusCompareWeight(TaxonNameBase<?,?> taxonNameBase) {

		int result = 0;

		if (taxonNameBase == null || taxonNameBase.getStatus() == null){

			return 0;

		}

		Set<NomenclaturalStatus> status1 = taxonNameBase.getStatus();

        for (NomenclaturalStatus nomStatus1 : status1){

            if (nomStatus1.getType() != null){

            	if (nomStatus1.getType().equals(NomenclaturalStatusType.INVALID())){

            		result += 1;

            	}else if(nomStatus1.getType().equals(NomenclaturalStatusType.NUDUM())){

            		result += 2;

                }

            }

        }

		return result;

	}

    private Integer getIntegerDate(TaxonNameBase<?,?> name){

        Integer result;

       if (name == null){

            result = null;

        }else{

            if (name instanceof ZoologicalName){

                result = (((ZoologicalName)name).getPublicationYear());

            }else{

                Reference<?> ref = (Reference<?>) name.getNomenclaturalReference();

                if (ref == null){

                    result = null;

                }else{

                    if (ref.getDatePublished() == null){

                    	Reference<?> inRef = ref.getInReference();

                    	if (inRef == null){

                            result = null;

                        }else{

                            if (inRef.getDatePublished() == null){

                            	result = null;

                            }else{

                            	result = ref.getInReference().getDatePublished().getStartYear();

                            }

                        }

                    }else{

                        result = ref.getDatePublished().getStartYear();

                    }

                }

            }

        }

        return result;

    }

    /**

     *

     * @param name1

     * @param name2

     * @return

     */

    protected int compare(TaxonNameBase<?,?> name1, TaxonNameBase<?,?> name2) {

        int result;

        //dates

        Integer intDate1 = getIntegerDate(name1);

        Integer intDate2 = getIntegerDate(name2);

        if (intDate1 == null && intDate2 == null){

            result = 0;

        }else if (intDate1 == null){

            return 1;

        }else if (intDate2 == null){

            return -1;

        }else{

            result = intDate1.compareTo(intDate2);

        }

        if (result == 0){

            result = name1.compareTo(name2);

            if (result != 0){

                return result;

            }

        }

        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.taxon;

import java.util.Comparator;

import java.util.Iterator;

/**

 * Comparator to compare {@link TaxonNode taxon nodes} by its user defined ordering

 * @author k.luther

 */

public class TaxonNaturalComparator implements Comparator<TaxonNode> {

    public TaxonNaturalComparator(){

		super();

	}

	@Override

	public int compare(TaxonNode node1, TaxonNode node2) {

//		TaxonNode node1 = null;

//		TaxonNode node2 = null;

//		if (taxon1.getTaxonNodes().size()>0 && taxon2.getTaxonNodes().size()>0){

//			for (TaxonNode node: taxon1.getTaxonNodes()){

//				if (node.getClassification().equals(classification)){

//					node1= node;

//					break;

//				}

//			}

//			for (TaxonNode node: taxon2.getTaxonNodes()){

//				if (node.getClassification().equals(classification)){

//					node2= node;

//					break;

//				}

//			}

//		}else{

//			return 0;

//		}

		if (node1.isAncestor(node2)) {

            return 1;

        }

		if (node2.isAncestor(node1)) {

            return -1;

        }

		if (node1.equals(node2)) {

            return 0;

        }

		String[] splitNode1 = node1.treeIndex().split("#");

		String[] splitNode2 = node2.treeIndex().split("#");

		if (splitNode1.length < splitNode2.length) {

            return 1;

        } else if (splitNode2.length < splitNode1.length) {

            return -1;

        }

		if (node1.getParent().equals(node2.getParent())){

			return node1.getSortIndex().compareTo(node2.getSortIndex());

		}

		String lastEqualAncestorTreeIndex = null;

		Iterator<TaxonNode> ancestorsNode1 = node1.getAncestors().iterator();

		Iterator<TaxonNode> ancestorsNode2 = node2.getAncestors().iterator();

		for (int i = 0; i < splitNode1.length; i++){

			if (!splitNode1[i].equals(splitNode2[i])){

				// take the last equal ancestor and compare the sortindex

				if (lastEqualAncestorTreeIndex != null){

					TaxonNode lastEqualTreeIndexAncestorNode1 = null;

					TaxonNode lastEqualTreeIndexAncestorNode2 = null;

					while (ancestorsNode1.hasNext()){

						TaxonNode next1 = ancestorsNode1.next();

						if (next1.treeIndex().equals(lastEqualAncestorTreeIndex)){

							lastEqualTreeIndexAncestorNode1 = next1;

						}

					}

					while (ancestorsNode2.hasNext()){

						TaxonNode next2 = ancestorsNode2.next();

						if (next2.treeIndex().equals(lastEqualAncestorTreeIndex)){

							lastEqualTreeIndexAncestorNode2 = next2;

						}

					}

					return lastEqualTreeIndexAncestorNode1.getSortIndex().compareTo(lastEqualTreeIndexAncestorNode2.getSortIndex());

				}

			}

			lastEqualAncestorTreeIndex = splitNode1[i];

		}

		return 0;

	}

}

/**

* 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.taxon;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collections;

import java.util.List;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.BeforeClass;

import org.junit.Test;

import eu.etaxonomy.cdm.model.common.TimePeriod;

import eu.etaxonomy.cdm.model.name.BotanicalName;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.name.ZoologicalName;

//import eu.etaxonomy.cdm.model.reference.Book;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

/**

 * @author a.mueller

 * @created 11.06.2008

 */

public class TaxonComparatorTest {

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

    /**

     * @throws java.lang.Exception

     */

    @BeforeClass

    public static void setUpBeforeClass() throws Exception {

    }

/******************** TESTS *****************************************************/

    /**

     * Test method for {@link eu.etaxonomy.cdm.model.taxon.TaxonComparator#compare(eu.etaxonomy.cdm.model.taxon.TaxonBase, eu.etaxonomy.cdm.model.taxon.TaxonBase)}.

     */

    @Test

    public void testCompare() {

        Reference<?> sec = ReferenceFactory.newBook();

        Reference<?> ref1 = ReferenceFactory.newBook();

        Reference<?> ref2 = ReferenceFactory.newBook();

        Reference<?> ref3 = ReferenceFactory.newBook();

        Calendar cal1 = Calendar.getInstance();

        Calendar cal2 = Calendar.getInstance();

        Calendar cal3 = Calendar.getInstance();

        cal1.set(1945, 3, 2);

        cal2.set(1856, 3, 2);

        cal3.set(1943, 3, 2);

        ref1.setDatePublished(TimePeriod.NewInstance(cal1));

//		ref2.setDatePublished(TimePeriod.NewInstance(cal2));

        ref3.setDatePublished(TimePeriod.NewInstance(cal3));

        BotanicalName botName1 =  BotanicalName.NewInstance(null);

        BotanicalName botName2 =  BotanicalName.NewInstance(null);

        BotanicalName botName3 =  BotanicalName.NewInstance(null);

        ZoologicalName zooName1 = ZoologicalName.NewInstance(null);

        botName1.setNomenclaturalReference(ref1);

        botName2.setNomenclaturalReference(ref2);

        botName3.setNomenclaturalReference(ref3);

        zooName1.setPublicationYear(1823);

        List<TaxonBase<?>> list = new ArrayList<TaxonBase<?>>();

        Taxon taxon1 = Taxon.NewInstance(botName1, sec);

        Taxon taxon2 = Taxon.NewInstance(botName2, sec);

        Taxon taxon3 = Taxon.NewInstance(botName3, sec);

        Taxon zooTaxon4 = Taxon.NewInstance(zooName1, sec);

        taxon1.setId(1);

        taxon2.setId(2);

        taxon3.setId(3);

        zooTaxon4.setId(4);

        list.add(taxon3);

        list.add(taxon2);

        list.add(taxon1);

        list.add(zooTaxon4);

        Collections.sort(list, new TaxonComparator());

        //Order should be

//        4: 1823

//        3: 1943

//        1: 1945

//        2:

        Assert.assertEquals(list.get(0).getId(), 4);

        Assert.assertEquals(getYear(list.get(0)), "1823");

        Assert.assertEquals(list.get(1).getId(), 3);

        Assert.assertEquals(getYear(list.get(1)), "1943");

        Assert.assertEquals(list.get(2).getId(), 1);

        Assert.assertEquals(getYear(list.get(2)), "1945");

        Assert.assertEquals(list.get(3).getId(), 2);

        Assert.assertEquals(getYear(list.get(3)), "");

    }

    /**

     * @param taxonBase

     * @return

     */

    private String getYear(TaxonBase<?> taxon) {

        String year = "";

        TaxonNameBase<?,?> tnb = taxon.getName();

        if (tnb instanceof ZoologicalName){

            year = String.valueOf(((ZoologicalName)tnb).getPublicationYear());

        }else{

            year = tnb.getNomenclaturalReference().getYear();

        }

        return year;

    }

}