private static final long serialVersionUID = -584946869762749006L;
private static final Logger logger = Logger.getLogger(Taxon.class);
+ private static final TaxonComparator defaultTaxonComparator = new TaxonComparator();
+
@XmlElementWrapper(name = "Descriptions")
@XmlElement(name = "Description")
@OneToMany(mappedBy="taxon", fetch= FetchType.LAZY)
* @see eu.etaxonomy.cdm.model.name.HomotypicalGroup#getSynonymsInGroup(Reference)
*/
@Transient
- public List<Synonym> getHomotypicSynonymsByHomotypicGroup(){
+ public List<Synonym> getHomotypicSynonymsByHomotypicGroup(TaxonComparator comparator){
if (this.getHomotypicGroup() == null){
return null;
- }else{
+ }else if (comparator == null){
return this.getSynonymsInGroup(this.getHomotypicGroup());
+ }else{
+ return this.getSynonymsInGroup(this.getHomotypicGroup(), comparator);
}
}
*/
@Transient
public List<HomotypicalGroup> getHomotypicSynonymyGroups(){
- List<HomotypicalGroup> result = new ArrayList<HomotypicalGroup>();
- result.add(this.getHomotypicGroup());
+ List<HomotypicalGroup> result = new ArrayList<>();
+ HomotypicalGroup myGroup = this.getHomotypicGroup();
+ if (myGroup != null){ //if taxon has no name HG might be null
+ result.add(myGroup);
+ }
for (TaxonNameBase taxonNameBase :this.getSynonymNames()){
if (taxonNameBase != null) {
if (!result.contains(taxonNameBase.getHomotypicalGroup())){
result.add(taxonNameBase.getHomotypicalGroup());
}
- } // TODO: give error message to user
+ }
}
- // TODO: sort list according to date of first published name within each group
return result;
}
@Transient
public List<HomotypicalGroup> getHeterotypicSynonymyGroups(){
List<HomotypicalGroup> list = getHomotypicSynonymyGroups();
+ //remove homotypic group
list.remove(this.getHomotypicGroup());
//sort
- Map<Synonym, HomotypicalGroup> map = new HashMap<Synonym, HomotypicalGroup>();
+ Map<Synonym, HomotypicalGroup> map = new HashMap<>();
for (HomotypicalGroup homotypicalGroup: list){
List<Synonym> synonymList = getSynonymsInGroup(homotypicalGroup);
if (synonymList.size() > 0){
map.put(synonymList.get(0), homotypicalGroup);
}
}
- List<Synonym> keyList = new ArrayList<Synonym>();
+ List<Synonym> keyList = new ArrayList<>();
keyList.addAll(map.keySet());
//order by first synonym
- Collections.sort(keyList, new TaxonComparator());
+ Collections.sort(keyList, defaultTaxonComparator);
- List<HomotypicalGroup> result = new ArrayList<HomotypicalGroup>();
+ List<HomotypicalGroup> result = new ArrayList<>();
for(Synonym synonym: keyList){
+ //"replace" synonyms by homotypic groups
result.add(map.get(synonym));
}
//sort end
*/
@Transient
public List<Synonym> getSynonymsInGroup(HomotypicalGroup homotypicGroup, TaxonComparator comparator){
- List<Synonym> result = new ArrayList<Synonym>();
+ List<Synonym> result = new ArrayList<>();
+ if (homotypicGroup == null){
+ return result; //always empty
+ }
- for (TaxonNameBase<?, ?>name : homotypicGroup.getTypifiedNames()){
- for (Synonym synonym : name.getSynonyms()){
- Taxon accTaxon = synonym.getAcceptedTaxon();
- if (accTaxon != null && accTaxon.equals(this) ) {
- result.add(synonym);
- }
+ for (Synonym synonym : this.getSynonyms()){
+ if (homotypicGroup.equals(synonym.getHomotypicGroup())){
+ result.add(synonym);
}
}
+
+// for (TaxonNameBase<?,?> name : homotypicGroup.getTypifiedNames()){
+// for (Synonym synonym : name.getSynonyms()){
+// Taxon accTaxon = synonym.getAcceptedTaxon();
+// if (accTaxon != null && accTaxon.equals(this) ) {
+// result.add(synonym);
+// }
+// }
+// }
Collections.sort(result, comparator);
return result;
}
@Autowired
private ITermService termService;
- @Autowired
- private IFeatureTreeService featureTreeService;
-
private static final List<String> TAXON_INIT_STRATEGY = Arrays.asList(new String []{
"$",
"sources",
"synonyms.name.status.type.representations",
"synonyms.name.nomenclaturalReference.authorship",
"synonyms.name.nomenclaturalReference.inReference",
- "synonyms.name.homotypicalGroup.typifiedNames.$",
- "synonyms.name.homotypicalGroup.typifiedNames.taxonBases.$",
+// "synonyms.name.homotypicalGroup.typifiedNames.$",
+// "synonyms.name.homotypicalGroup.typifiedNames.taxonBases.$",
"synonyms.name.combinationAuthorship.$",
"name.typeDesignations",
"name.homotypicalGroup.typifiedNames.$",
"name.homotypicalGroup.typifiedNames.nomenclaturalReference.authorship",
"name.homotypicalGroup.typifiedNames.nomenclaturalReference.inReference",
- "name.homotypicalGroup.typifiedNames.taxonBases.$"
+// "name.homotypicalGroup.typifiedNames.taxonBases.$"
});
@Override
public List<String> getIgnorePropNames() {
return Arrays.asList(new String[]{
- "acceptedTaxon"
+// "acceptedTaxon" //#6211 to avoid infinite loops
});
}
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
+import eu.etaxonomy.cdm.model.taxon.HomotypicGroupTaxonComparator;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.SynonymType;
@Override
public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){
- List<List<Synonym>> result = new ArrayList<List<Synonym>>();
- Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
+ List<List<Synonym>> result = new ArrayList<>();
+ taxon = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
+ HomotypicGroupTaxonComparator comparator = new HomotypicGroupTaxonComparator(taxon);
+
//homotypic
- result.add(t.getHomotypicSynonymsByHomotypicGroup());
+ result.add(taxon.getHomotypicSynonymsByHomotypicGroup(comparator));
//heterotypic
- List<HomotypicalGroup> homotypicalGroups = t.getHeterotypicSynonymyGroups();
+ List<HomotypicalGroup> homotypicalGroups = taxon.getHeterotypicSynonymyGroups(); //currently the list is sorted by the Taxon.defaultTaxonComparator
for(HomotypicalGroup homotypicalGroup : homotypicalGroups){
- result.add(t.getSynonymsInGroup(homotypicalGroup));
+ result.add(taxon.getSynonymsInGroup(homotypicalGroup, comparator));
}
return result;
@Override
public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths){
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
- return t.getHomotypicSynonymsByHomotypicGroup();
+ HomotypicGroupTaxonComparator comparator = new HomotypicGroupTaxonComparator(taxon);
+
+ return t.getHomotypicSynonymsByHomotypicGroup(comparator);
}
@Override
public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths){
Taxon t = (Taxon)dao.load(taxon.getUuid(), propertyPaths);
List<HomotypicalGroup> homotypicalGroups = t.getHeterotypicSynonymyGroups();
- List<List<Synonym>> heterotypicSynonymyGroups = new ArrayList<List<Synonym>>(homotypicalGroups.size());
+ List<List<Synonym>> heterotypicSynonymyGroups = new ArrayList<>(homotypicalGroups.size());
for(HomotypicalGroup homotypicalGroup : homotypicalGroups){
heterotypicSynonymyGroups.add(t.getSynonymsInGroup(homotypicalGroup));
}
Assert.assertEquals("'homotypicSynonym' must have exactly 2 basionym relationships", 2, homotypicSynonym.getName().getNameRelations().size());
Assert.assertEquals("'t1' must have exactly 1 basionym relationships", 1, t1.getName().getBasionyms().size());
Assert.assertEquals("'t1' must have exactly 2 homotypic synonyms", 2, t1.getHomotypicSynonymsByHomotypicSynonymType().size());
- Assert.assertEquals("'t1' must have exactly 2 names in homotypic group", 2, t1.getHomotypicSynonymsByHomotypicGroup().size());
+ Assert.assertEquals("'t1' must have exactly 2 names in homotypic group", 2, t1.getHomotypicSynonymsByHomotypicGroup(null).size());
Assert.assertEquals("'t1' homotypic group must include 3 names (t1, s2, homotypicSynonym)", 3, t1.getHomotypicGroup().getTypifiedNames().size());
Assert.assertEquals("'homotypicSynonym' must have exactly 1 basionym relationships", 1, homotypicSynonym.getName().getNameRelations().size());
Assert.assertEquals("'t1' must have exactly 1 basionym relationships", 1, t1.getName().getBasionyms().size());
Assert.assertEquals("'t1' must have exactly 1 homotypic synonyms", 1, t1.getHomotypicSynonymsByHomotypicSynonymType().size());
- Assert.assertEquals("'t1' must have exactly 1 names in homotypic group", 1, t1.getHomotypicSynonymsByHomotypicGroup().size());
+ Assert.assertEquals("'t1' must have exactly 1 names in homotypic group", 1, t1.getHomotypicSynonymsByHomotypicGroup(null).size());
Assert.assertEquals("'t1' homotypic group must include 2 names (t1, homotypicSynonym)", 2, t1.getHomotypicGroup().getTypifiedNames().size());
//do it