EDIT

/**

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

*/

import java.util.Comparator;

import java.util.HashSet;

import java.util.Set;

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

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

/**

 * 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 and equal rank are sorted alphabetically</li>

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

 *  </ul>

 *

 * @author a.mueller

public class HomotypicGroupTaxonComparator extends TaxonComparator {

    private final TaxonBase<?> firstTaxonInGroup;

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

        this.firstTaxonInGroup = firstTaxonInGroup;

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

    }

    public HomotypicGroupTaxonComparator(@SuppressWarnings("rawtypes") TaxonBase firstTaxonInGroup, boolean includeRanks) {

        super(includeRanks);

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

    }

        super(includeRanks);

        firstTaxonInGroup = null;

        this.firstNameInGroup = firstNameInGroup;

    }

     *

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

        TaxonName name2 = taxonBase2.getName();

        return compareNames(name1, name2, taxonBase1, taxonBase2);

    }

    public int compareNames(TaxonName name1,  TaxonName name2, TaxonBase<?> taxonBase1, TaxonBase<?> taxonBase2) {

                name2 == null && taxonBase2 == null){

            throw new IllegalArgumentException("There should always be either a name or a taxon to be compared");

        }

        int compareStatus = compareStatus(name1, name2);

        if (compareStatus != 0){

            return compareStatus;

        }

        //not same homotypical group -

        //NOTE: this comparator should usually not be used

        //      which follows the contract of Comparator#compare.

        if (name1 == null ||

            name2 == null ||

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

                    name1.getHomotypicalGroup().getUuid().toString() :

                    taxonBase1.getUuid().toString();

            String compareString2 = name2 != null ?

                    name2.getHomotypicalGroup().getUuid().toString() :

                    taxonBase2.getUuid().toString();

            int result = compareString1.compareTo(compareString2);

        }

        //same homotypical group ...

        //one taxon is first in group

        }

        //same name => compare on taxon level

        if (name1.equals(name2)){

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

        }

        TaxonName 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){

        }else{

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

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

        }

    }

        if (taxonBase != null){

            return taxonBase.equals(firstTaxonInGroup);

        }else{

            return name.equals(firstNameInGroup);

        }

    }

     * 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 name1 first name to compare

     * @param name2 second name to compare

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

     */

            TaxonName name1,

            TaxonName name2) {

        if (basionym.equals(name1)){

            return -1;

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

            return 1;

        }else{

        TaxonName basionym2 = getFirstNameInGroup(basionym2Orig);

            return -1;

        }

        boolean basio1IsReplacedSynForBasio2 = getReplacedSynonymClosure(basionym2).contains(basionym1);

        if (basio2IsReplacedSynForBasio1 && !basio1IsReplacedSynForBasio2){

        }

        return super.compare(basionym1, basionym2, true);

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

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

                    return firstNameInGroup;

                }

            }

        }

        return basionym;

    }

            return set;

        }

            if (notYetContained){

                result.addAll(replSyn.getReplacedSynonyms());

            }

        }

        return result;

    }

        Set<TaxonName> candidates = new HashSet<>();

                    && candidate.getHomotypicalGroup().equals(name.getHomotypicalGroup())

                    && !hasBasionymCircle(candidate, null)){

                candidate = getPreferredInBasionymGroup(candidate);

                candidates.add(candidate);

        }

        if (candidates.isEmpty()){

            return name;

            return candidates.iterator().next();

        }else{

                }

            }

            return result;

        }

    }

        if (existing.contains(name)){

            return true;

                return false;

            }

            existing.add(name);

                    return true;

                }

            }

            return false;

    }