}
- private List<TaxonName<?,?>> buildNameList( InputStream content, ICdmRepository repository, IIpniServiceConfigurator iConfig) throws IOException {
+ private List<TaxonName> buildNameList( InputStream content, ICdmRepository repository, IIpniServiceConfigurator iConfig) throws IOException {
IpniServiceNamesConfigurator config = (IpniServiceNamesConfigurator)iConfig;
- List<TaxonName<?,?>> result = new ArrayList<>();
+ List<TaxonName> result = new ArrayList<>();
BufferedReader reader = new BufferedReader (new InputStreamReader(content));
String headerLine = reader.readLine();
*
* @see #getTaxonDescription(Taxon, boolean, boolean)
*/
- public TaxonNameDescription getTaxonNameDescription(TaxonName<?,?> name, Reference ref, boolean isImageGallery, boolean createNewIfNotExists) {
+ public TaxonNameDescription getTaxonNameDescription(TaxonName name, Reference ref, boolean isImageGallery, boolean createNewIfNotExists) {
TaxonNameDescription result = null;
Set<TaxonNameDescription> descriptions= name.getDescriptions();
for (TaxonNameDescription description : descriptions){
}
}else if (inDescription.isInstanceOf(TaxonNameDescription.class)){
TaxonNameDescription nameDescription = CdmBase.deproxy(inDescription, TaxonNameDescription.class);
- TaxonName<?,?> taxonName = nameDescription.getTaxonName();
+ TaxonName taxonName = nameDescription.getTaxonName();
if (isCache){
return taxonName.getTitleCache();
}else{
if (cdmBase.isInstanceOf(OriginalSourceBase.class)){
OriginalSourceBase<?> source = CdmBase.deproxy(cdmBase, OriginalSourceBase.class);
String nameString = source.getOriginalNameString();
- TaxonName<?,?> name = null;
+ TaxonName name = null;
if (source.isInstanceOf(DescriptionElementSource.class)){
DescriptionElementSource descSource = CdmBase.deproxy(source, DescriptionElementSource.class);
name = descSource.getNameUsedInSource();
private void initNameMap(STATE state) {
if (!nameMapIsInitialized && repository != null){
List<String> propertyPaths = Arrays.asList("");
- List<TaxonName<?,?>> existingNames = repository.getNameService().list(null, null, null, null, propertyPaths);
- for (TaxonName<?,?> name : existingNames){
+ List<TaxonName> existingNames = repository.getNameService().list(null, null, null, null, propertyPaths);
+ for (TaxonName name : existingNames){
putName(name.getTitleCache(), name);
}
nameMapIsInitialized = true;
Rank rank = getRank(csvTaxonRecord, nomCode);
//name && name published in
- TaxonName<?,?> name = getScientificName(csvTaxonRecord, nomCode, rank, resultList, sourceReference);
+ TaxonName name = getScientificName(csvTaxonRecord, nomCode, rank, resultList, sourceReference);
taxonBase.setName(name);
//nameAccordingTo
}
- private TaxonName<?,?> getScientificName(StreamItem item, NomenclaturalCode nomCode, Rank rank, List<MappedCdmBase> resultList, Reference sourceReference) {
- TaxonName<?,?> name = null;
+ private TaxonName getScientificName(StreamItem item, NomenclaturalCode nomCode, Rank rank, List<MappedCdmBase> resultList, Reference sourceReference) {
+ TaxonName name = null;
String strScientificName = getValue(item, TermUri.DWC_SCIENTIFIC_NAME);
//Name
if (strScientificName != null){
- name = (TaxonName<?,?>)parser.parseFullName(strScientificName, nomCode, rank);
+ name = (TaxonName)parser.parseFullName(strScientificName, nomCode, rank);
if ( rank != null && name != null && name.getRank() != null && ! rank.equals(name.getRank())){
if (config.isValidateRankConsistency()){
String message = "Parsed rank %s (%s) differs from rank %s given by fields 'taxonRank' or 'verbatimTaxonRank'";
//TODO we may configure in configuration that scientific name never includes Authorship
- private void checkAuthorship(TaxonName<?,?> nameBase, StreamItem item) {
+ private void checkAuthorship(TaxonName nameBase, StreamItem item) {
if (!nameBase.isNonViral()){
return;
}
* @return
*/
private TaxonBase<?> getTaxonBase(StreamItem item) {
- TaxonName<?,?> name = null;
+ TaxonName name = null;
Reference sec = null;
TaxonBase<?> result;
String taxStatus = item.get(TermUri.DWC_TAXONOMIC_STATUS);
return true;\r
}\r
\r
- private TaxonName<?,?> getScientificName(DerivedUnitFacade facade) {\r
+ private TaxonName getScientificName(DerivedUnitFacade facade) {\r
Set<DeterminationEvent> detEvents = facade.getDeterminations();\r
for (DeterminationEvent detEvent : detEvents){\r
if (detEvent.getPreferredFlag()== true || detEvents.size()==1){\r
}\r
\r
// get the taxa for the matching names\r
- for(TaxonName<?,?> dbTaxonName: taxonNames) {\r
+ for(TaxonName dbTaxonName: taxonNames) {\r
\r
Set<Taxon> taxa = dbTaxonName.getTaxa();\r
if (taxa.isEmpty()) {\r
//TODO implementation must be improved when matching of taxon names with existing names is implemented
//=> the assumption that the only description is the description added by this import
//is wrong then
- private TaxonNameDescription getNameDescription(TaxonName<?,?> name) {
+ private TaxonNameDescription getNameDescription(TaxonName name) {
Set<TaxonNameDescription> descriptions = name.getDescriptions();
if (descriptions.size()>1){
throw new IllegalStateException("Implementation does not yet support names with multiple descriptions");
// this a rule?
TaxonName speciesName = TaxonName.castAndDeproxy(
handleNom(state, reader, next, null));
- for (TaxonName<?, ?> name : homotypicalGroup
+ for (TaxonName name : homotypicalGroup
.getTypifiedNames()) {
name.addNameTypeDesignation(speciesName, null, null,
null, status, false, false, false, false);
* TypeDesignatedByRef_Fk
*/
- private void handleTypeDesignations(OutputModelExportState state, TaxonName name){
- Set<SpecimenTypeDesignation> typeDesignations = name.getTypeDesignations();
+ private void handleSpecimenTypeDesignations(OutputModelExportState state, TaxonName name){
+ Set<SpecimenTypeDesignation> typeDesignations = name.getSpecimenTypeDesignations();
OutputModelTable table = OutputModelTable.TYPE_DESIGNATION;
String nameId = getId(state, name);
String[] csvLine = new String[table.getSize()];
}
if(taxonName==null && atomisedTaxonName!=null){
- taxonName = (TaxonName<?, ?>) atomisedTaxonName;
+ taxonName = (TaxonName) atomisedTaxonName;
state.getReport().addName(taxonName);
logger.info("Created new taxon name "+taxonName);
if(taxonName.hasProblem()){
if (result == null){
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
NomenclaturalCode code = state.getConfig().getNomenclaturalCode();
- result = (TaxonName<?,?>)parser.parseFullName(name, code, null);
+ result = (TaxonName)parser.parseFullName(name, code, null);
}
if (result != null){
taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setTitleCache(scientificName, true);
}
- getNameService().save((TaxonName<?,?>)taxonName);
+ getNameService().save((TaxonName)taxonName);
taxon = Taxon.NewInstance(taxonName, ref); //sec set null
getTaxonService().save(taxon);
// refreshTransaction();
private DerivationEvent derivationEvent;\r
private DerivedUnit specimen;\r
private Collection collection;\r
- private TaxonName<?, ?> storedUnderName;\r
+ private TaxonName storedUnderName;\r
private String titleCache;\r
\r
\r
/**\r
* @return the storedUnderName\r
*/\r
- public TaxonName<?, ?> getStoredUnderName() {\r
+ public TaxonName getStoredUnderName() {\r
return storedUnderName;\r
}\r
\r
/**\r
* @param storedUnderName the storedUnderName to set\r
*/\r
- public void setStoredUnderName(TaxonName<?, ?> storedUnderName) {\r
+ public void setStoredUnderName(TaxonName storedUnderName) {\r
this.storedUnderName = storedUnderName;\r
}\r
\r
String[] collectionStrings = typeLocStatus.substring(pos).split(",");\r
for(String collectionString : collectionStrings){\r
if (taxonBase != null){\r
- TaxonName<?,?> taxonName = taxonBase.getName();\r
+ TaxonName taxonName = taxonBase.getName();\r
if (taxonName != null){\r
Reference citation = null;\r
String citationMicroReference = null;\r
\r
logger.info("start make TaxonConcepts ...");\r
MapWrapper<TaxonBase> taxonMap = (MapWrapper<TaxonBase>)state.getStore(ICdmIO.TAXON_STORE);\r
- MapWrapper<TaxonName<?,?>> taxonNameMap = (MapWrapper<TaxonName<?,?>>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
+ MapWrapper<TaxonName> taxonNameMap = (MapWrapper<TaxonName>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
MapWrapper<Reference> referenceMap = (MapWrapper<Reference>)state.getStore(ICdmIO.REFERENCE_STORE);\r
Map<String, CommonTaxonName> commonNameMap = new HashMap<String, CommonTaxonName>();\r
\r
* @param elTaxonRelationships\r
* @param success\r
*/\r
- private TaxonName<?, ?> makeScientificName(Element elName, NomenclaturalCode code, MapWrapper<? extends TaxonName<?,?>> objectMap, ResultWrapper<Boolean> success){\r
- TaxonName<?,?> result = null;\r
+ private TaxonName makeScientificName(Element elName, NomenclaturalCode code, MapWrapper<? extends TaxonName> objectMap, ResultWrapper<Boolean> success){\r
+ TaxonName result = null;\r
if (elName != null){\r
String language = elName.getAttributeValue("language");\r
//Language\r
logger.warn("language for name not yet implemented. Language for scientific name should always be Latin");\r
}\r
Class<? extends IdentifiableEntity> clazz = TaxonName.class;\r
- result = (TaxonName<?,?>)makeReferenceType (elName, clazz , objectMap, success);\r
+ result = (TaxonName)makeReferenceType (elName, clazz , objectMap, success);\r
if(result == null){\r
logger.warn("Name not found");\r
success.setValue(false);\r
\r
\r
logger.info("start make taxon name relations ...");\r
- MapWrapper<TaxonName<?,?>> taxonNameMap = (MapWrapper<TaxonName<?,?>>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
+ MapWrapper<TaxonName> taxonNameMap = (MapWrapper<TaxonName>)state.getStore(ICdmIO.TAXONNAME_STORE);\r
MapWrapper<Reference> referenceMap = (MapWrapper<Reference>)state.getStore(ICdmIO.REFERENCE_STORE);\r
\r
Set<TaxonName> nameStore = new HashSet<TaxonName>();\r
}\r
\r
\r
- private boolean makeNomenclaturalNoteType(TcsXmlImportConfigurator tcsConfig, Element elRelation, NameRelationshipType relType, MapWrapper<TaxonName<?,?>> taxonNameMap, Set<TaxonName> nameStore, String id, boolean inverse){\r
+ private boolean makeNomenclaturalNoteType(TcsXmlImportConfigurator tcsConfig, Element elRelation, NameRelationshipType relType, MapWrapper<TaxonName> taxonNameMap, Set<TaxonName> nameStore, String id, boolean inverse){\r
if (elRelation == null){\r
return false;\r
}\r
TaxonName aboutName = aboutTaxon.getName();\r
if (aboutName != null){\r
Set<TaxonName> typifiedNames = aboutName.getHomotypicalGroup().getTypifiedNames();\r
- for (TaxonName<?,?> typifiedName : typifiedNames){\r
+ for (TaxonName typifiedName : typifiedNames){\r
//TODO check if name is part of this tcs file\r
if (typifiedName.equals(aboutName)){\r
continue;\r
ICdmDataSource datasource = mapping.getDatabase();
Assert.assertNotNull("Datasource should not be null", datasource);
- TaxonName<?,?> botName1 = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonName botName1 = TaxonNameFactory.NewBotanicalInstance(null);
int id = 23;
botName1.setId(id);
String sourceNS = "sourceNS";
assertEquals(3, nameService.count(TaxonName.class));
assertEquals(1, occurrenceService.count(DerivedUnit.class));
boolean varietyFound = false;
- for(TaxonName<?, ?> name:nameService.list(TaxonName.class, null, null, null, null)){
+ for(TaxonName name:nameService.list(TaxonName.class, null, null, null, null)){
if(name.getRank().equals(Rank.VARIETY())){
varietyFound = true;
}
private void setTarget(IIntextReferenceTarget target) {\r
target = CdmBase.deproxy(target);\r
if (target instanceof TaxonName){\r
- this.taxonName = (TaxonName<?,?>)target;\r
+ this.taxonName = (TaxonName)target;\r
}else if (target instanceof TaxonBase){\r
this.taxon = (TaxonBase<?>)target;\r
}else if (target instanceof SpecimenOrObservationBase){\r
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch = FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonName<?,?> nameUsedInSource;
+ private TaxonName nameUsedInSource;
//*********************** CONSTRUCTOR ******************************/
@ManyToOne(fetch = FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
@FieldBridge(impl=NotNullAwareIdBridge.class)
- private TaxonName<?,?> taxonName;
+ private TaxonName taxonName;
//******************* FACTORY ********************************************/
* Returns the {@link TaxonName taxon name} to which <i>this</i> taxon name description
* provides additional information not ruled by a {@link NomenclaturalCode nomenclatural code}.
*/
- public TaxonName<?,?> getTaxonName() {
+ public TaxonName getTaxonName() {
return taxonName;
}
// */
// public void guessAndSetBasionym(){
// Map<String, INonViralName> candidates = new HashMap<>();
-// for (TaxonName<?,?> typifiedName : this.typifiedNames){
+// for (TaxonName typifiedName : this.typifiedNames){
// if (! typifiedName.protectedAuthorshipCache && nvn.getBasionymAuthorship() == null){
// candidates.add(typifiedName);
// }
// }
// if (candidates.size() == 1){
-// for (TaxonName<?,?> typifiedName : this.typifiedNames){
+// for (TaxonName typifiedName : this.typifiedNames){
// removeGroupBasionym(typifiedName);
// }
// this.setGroupBasionym(candidates.iterator().next());
TaxonComparator taxComparator = new HomotypicGroupTaxonComparator(null);
Set<TaxonName> typifiedNames1 = group1.getTypifiedNames();
List<TaxonBase> taxonBasesOfTypifiedNames = new ArrayList<>();
- for (TaxonName<?,?> typifiedName:typifiedNames1){
+ for (TaxonName typifiedName:typifiedNames1){
if (!typifiedName.getTaxonBases().isEmpty()){
taxonBasesOfTypifiedNames.add(typifiedName.getTaxonBases().iterator().next());
}
Set<TaxonName> typifiedNames2 = group2.getTypifiedNames();
taxonBasesOfTypifiedNames = new ArrayList<TaxonBase>();
- for (TaxonName<?,?> typifiedName:typifiedNames2){
+ for (TaxonName typifiedName:typifiedNames2){
if (!typifiedName.getTaxonBases().isEmpty()){
taxonBasesOfTypifiedNames.add(typifiedName.getTaxonBases().iterator().next());
}
* @param name2 second name to compare
* @return compare value according to the {@link Comparator#compare(Object, Object)} contract.
*/
- private int handleSameBasionym(TaxonName<?, ?> basionym,
- TaxonName<?, ?> name1,
- TaxonName<?, ?> name2) {
+ private int handleSameBasionym(TaxonName basionym,
+ TaxonName name1,
+ TaxonName name2) {
if (basionym.equals(name1)){
return -1;
* @param basionym2
* @return
*/
- private int compareBasionyms(TaxonName<?,?> basionym1Orig, TaxonName basionym2Orig) {
+ private int compareBasionyms(TaxonName basionym1Orig, TaxonName basionym2Orig) {
//one taxon is first in group
TaxonName basionym1 = getFirstNameInGroup(basionym1Orig);
TaxonName basionym2 = getFirstNameInGroup(basionym2Orig);
* @param basionym
* @return
*/
- private TaxonName<?, ?> getFirstNameInGroup(TaxonName<?, ?> basionym) {
+ private TaxonName getFirstNameInGroup(TaxonName basionym) {
for (NameRelationship nameRel : basionym.getRelationsFromThisName()){
if (nameRel.getType() != null && nameRel.getType().equals(NameRelationshipType.BASIONYM())){
if (nameRel.getToName().equals(firstNameInGroup)){
* @return
*/
@SuppressWarnings("rawtypes")
- private Set<TaxonName> getReplacedSynonymClosure(TaxonName<?, ?> name) {
+ private Set<TaxonName> getReplacedSynonymClosure(TaxonName name) {
Set<TaxonName> set = name.getReplacedSynonyms();
if (set.isEmpty()){
return set;
}
Set<TaxonName> result = new HashSet<TaxonName>();
- for (TaxonName<?,?> replSyn : set){
+ for (TaxonName replSyn : set){
boolean notYetContained = result.add(replSyn);
if (notYetContained){
result.addAll(replSyn.getReplacedSynonyms());
* @param name
* @return
*/
- private TaxonName getPreferredInBasionymGroup(TaxonName<?,?> name) {
+ private TaxonName getPreferredInBasionymGroup(TaxonName name) {
Set<TaxonName> candidates = new HashSet<>();
//get all final basionyms, except for those being part of a basionym circle
- for (TaxonName<?,?> candidate : name.getBasionyms()){
+ for (TaxonName candidate : name.getBasionyms()){
if (candidate != null
&& candidate.getHomotypicalGroup().equals(name.getHomotypicalGroup())
&& !hasBasionymCircle(candidate, null)){
}else{
TaxonName result = candidates.iterator().next();
candidates.remove(result);
- for(TaxonName<?,?> candidate : candidates){
+ for(TaxonName candidate : candidates){
if (this.compare(result, candidate) > 0){
result = candidate;
}
* @param candidate
* @return
*/
- private boolean hasBasionymCircle(TaxonName<?, ?> name, Set<TaxonName<?,?>> existing) {
+ private boolean hasBasionymCircle(TaxonName name, Set<TaxonName> existing) {
if (existing == null){
existing = new HashSet<>();
}
* without status nom. illeg.
* @return
*/
- protected int compare(TaxonName<?,?> name1, TaxonName name2, boolean includeNomIlleg) {
+ protected int compare(TaxonName name1, TaxonName name2, boolean includeNomIlleg) {
int result;
//dates
return result;
}
- private Integer getIntegerDate(TaxonName<?,?> name){
+ private Integer getIntegerDate(TaxonName name){
Integer result;
if (name == null){
return result;
}
- protected int compareNomIlleg(TaxonName<?,?> taxonName1, TaxonName taxonName2) {
+ protected int compareNomIlleg(TaxonName taxonName1, TaxonName taxonName2) {
int isNomIlleg1 = isNomIlleg(taxonName1);
int isNomIlleg2 = isNomIlleg(taxonName2);
return isNomIlleg1 - isNomIlleg2;
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch=FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonName<?,?> relatedFrom;
+ private TaxonName relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch=FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonName<?,?> relatedTo;
+ private TaxonName relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
if (compareType != 0){
return compareType;
}else{
- TaxonName<?,?> related1 = this.getRelatedFrom();
- TaxonName<?,?> related2 = rel2.getRelatedFrom();
+ TaxonName related1 = this.getRelatedFrom();
+ TaxonName related2 = rel2.getRelatedFrom();
if (related1 != related2){
related1 = this.getRelatedTo();
related2 = rel2.getRelatedTo();
* @return the compareTo result similar to {@link Comparable#compareTo(Object)}
* @throws NullPointerException if otherTaxon is <code>null</code>
*/
- public int compareToName(TaxonName<?,?> otherName);
+ public int compareToName(TaxonName otherName);
/**
* This method returns als {@link Registration registrations} for the given name.
@NameMustHaveAuthority(groups = Level2.class)
@NoDuplicateNames(groups = Level3.class)
@Indexed(index = "eu.etaxonomy.cdm.model.name.TaxonName")
-public class TaxonName<T extends TaxonName<?,?>, S extends INameCacheStrategy>
- extends IdentifiableEntity<S>
+public class TaxonName
+ extends IdentifiableEntity<INameCacheStrategy>
implements ITaxonNameBase, INonViralName, IViralName, IBacterialName, IZoologicalName,
IBotanicalName, ICultivarPlantName, IFungusName,
IParsable, IRelated, IMatchable, IIntextReferenceTarget, Cloneable {
*/
protected static TaxonName NewInstance(NomenclaturalCode code, Rank rank,
HomotypicalGroup homotypicalGroup) {
- TaxonName<?,?> result = new TaxonName<>(code, rank, homotypicalGroup);
+ TaxonName result = new TaxonName(code, rank, homotypicalGroup);
return result;
}
String infraGenericEpithet, String specificEpithet, String infraSpecificEpithet,
TeamOrPersonBase combinationAuthorship, Reference nomenclaturalReference,
String nomenclMicroRef, HomotypicalGroup homotypicalGroup) {
- TaxonName result = new TaxonName<>(code, rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);
+ TaxonName result = new TaxonName(code, rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);
return result;
}
}else if (this.cacheStrategy != null){
//
}else if (getNameType() == NomenclaturalCode.NonViral){
- this.cacheStrategy = (S)NonViralNameDefaultCacheStrategy.NewInstance();
+ this.cacheStrategy = NonViralNameDefaultCacheStrategy.NewInstance();
}else if (getNameType().isBotanical()){
- this.cacheStrategy = (S)NonViralNameDefaultCacheStrategy.NewInstance();
+ this.cacheStrategy = NonViralNameDefaultCacheStrategy.NewInstance();
}else if (getNameType() == NomenclaturalCode.ICZN){
- this.cacheStrategy = (S)NonViralNameDefaultCacheStrategy.NewInstance();
+ this.cacheStrategy = NonViralNameDefaultCacheStrategy.NewInstance();
}else if (getNameType() == NomenclaturalCode.ICNB){
- this.cacheStrategy = (S)NonViralNameDefaultCacheStrategy.NewInstance();;
+ this.cacheStrategy = NonViralNameDefaultCacheStrategy.NewInstance();;
}else if (getNameType() == NomenclaturalCode.ICVCN){
- this.cacheStrategy = (S) ViralNameDefaultCacheStrategy.NewInstance();
+ this.cacheStrategy = ViralNameDefaultCacheStrategy.NewInstance();
}
}
return;
}
- TaxonName<?,?> parent = hybridRelation.getParentName();
- TaxonName<?,?> child = hybridRelation.getHybridName();
+ TaxonName parent = hybridRelation.getParentName();
+ TaxonName child = hybridRelation.getHybridName();
if (this.equals(parent)){
this.hybridParentRelations.remove(hybridRelation);
child.hybridChildRelations.remove(hybridRelation);
//********* METHODS **************************************/
@Override
- public S getCacheStrategy() {
+ public INameCacheStrategy getCacheStrategy() {
rectifyNameCacheStrategy();
return this.cacheStrategy;
}
@Override
@Transient
public List<TaggedText> getTaggedName(){
- S strat = getCacheStrategy();
+ INameCacheStrategy strat = getCacheStrategy();
return strat.getTaggedTitle(this);
}
Set<NameRelationship> rels = this.getRelationsToThisName();
for (NameRelationship rel : rels){
if (rel.getType()!= null && rel.getType().isBasionymRelation()){
- TaxonName<?,?> basionym = rel.getFromName();
+ TaxonName basionym = rel.getFromName();
result.add(basionym);
}
}
return false;
}
- for (TaxonName<?,?> taxonName : typifiedNames) {
+ for (TaxonName taxonName : typifiedNames) {
if (!taxonName.equals(this)) {
if (! isBasionymFor(taxonName)) {
return false;
Set<NameRelationship> relations = new HashSet<NameRelationship>();
Set<NameRelationship> removeRelations = new HashSet<NameRelationship>();
- for(TaxonName<?, ?> typifiedName : homotypicalGroup.getTypifiedNames()){
+ for(TaxonName typifiedName : homotypicalGroup.getTypifiedNames()){
Set<NameRelationship> nameRelations = typifiedName.getRelationsFromThisName();
this.removeNameRelationship(relation);
}
- for (TaxonName<?, ?> name : homotypicalGroup.getTypifiedNames()) {
+ for (TaxonName name : homotypicalGroup.getTypifiedNames()) {
if (!name.equals(this)) {
// First check whether the relationship already exists
Set<NameRelationship> relations = new HashSet<NameRelationship>();
Set<NameRelationship> removeRelations = new HashSet<NameRelationship>();
- for(TaxonName<?, ?> typifiedName : homotypicalGroup.getTypifiedNames()){
+ for(TaxonName typifiedName : homotypicalGroup.getTypifiedNames()){
Set<NameRelationship> nameRelations = typifiedName.getRelationsFromThisName();
// ***************** COMPARE ********************************/
@Override
- public int compareToName(TaxonName<?,?> otherName){
+ public int compareToName(TaxonName otherName){
int result = 0;
*/
@Override
public Object clone() {
- TaxonName<?,?> result;
+ TaxonName result;
try {
result = (TaxonName)super.clone();
* @param rank
* @return
*/
- public static TaxonName<?, ?> NewFungusInstance(Rank rank) {
+ public static TaxonName NewFungusInstance(Rank rank) {
return TaxonName.NewInstance(NomenclaturalCode.Fungi, rank, null);
}
@ManyToOne(fetch = FetchType.LAZY)
@IndexedEmbedded(includeEmbeddedObjectId=true)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonName<?,?> taxonName;
+ private TaxonName taxonName;
@XmlElement(name = "Modifier")
@XmlIDREF
* @param basionym
* @return
*/
- private TaxonName getFirstNameInGroup(TaxonName<?,?> basionym) {
+ private TaxonName getFirstNameInGroup(TaxonName basionym) {
for (NameRelationship nameRel : basionym.getRelationsFromThisName()){
if (nameRel.getType() != null && nameRel.getType().equals(NameRelationshipType.BASIONYM())){
if (nameRel.getToName().equals(firstNameInGroup)){
* @return
*/
@SuppressWarnings("rawtypes")
- private Set<TaxonName> getReplacedSynonymClosure(TaxonName<?, ?> name) {
+ private Set<TaxonName> getReplacedSynonymClosure(TaxonName name) {
Set<TaxonName> set = name.getReplacedSynonyms();
if (set.isEmpty()){
return set;
}
Set<TaxonName> result = new HashSet<>();
- for (TaxonName<?,?> replSyn : set){
+ for (TaxonName replSyn : set){
boolean notYetContained = result.add(replSyn);
if (notYetContained){
result.addAll(replSyn.getReplacedSynonyms());
* @param name
* @return
*/
- private TaxonName getPreferredInBasionymGroup(TaxonName<?,?> name) {
- Set<TaxonName<?,?>> candidates = new HashSet<>();
+ private TaxonName getPreferredInBasionymGroup(TaxonName name) {
+ Set<TaxonName> candidates = new HashSet<>();
//get all final basionyms, except for those being part of a basionym circle
- for (TaxonName<?,?> candidate : name.getBasionyms()){
+ for (TaxonName candidate : name.getBasionyms()){
if (candidate != null
&& candidate.getHomotypicalGroup().equals(name.getHomotypicalGroup())
&& !hasBasionymCircle(candidate, null)){
}else{
TaxonName result = candidates.iterator().next();
candidates.remove(result);
- for (TaxonName<?,?> candidate : candidates){
+ for (TaxonName candidate : candidates){
if (super.compare(result, candidate, false) > 0){
result = candidate;
}
* @param candidate
* @return
*/
- private boolean hasBasionymCircle(TaxonName<?, ?> name, Set<TaxonName> existing) {
+ private boolean hasBasionymCircle(TaxonName name, Set<TaxonName> existing) {
if (existing == null){
existing = new HashSet<>();
}
@IndexedEmbedded(includeEmbeddedObjectId=true)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
@NotNull(groups = Level2.class)
- private TaxonName<?,?> name;
+ private TaxonName name;
// The concept reference
@XmlElement(name = "Sec")
otherTaxon = deproxy(otherTaxon);
- TaxonName<?,?> otherName = deproxy(otherTaxon.getName());
+ TaxonName otherName = deproxy(otherTaxon.getName());
ITaxonNameBase thisName = this.getName();
if ((otherName == null || thisName == null)){
if (otherName != thisName){
private <X extends ITaxonNameBase> List<TaggedText> getNameTags(T taxonBase) {
List<TaggedText> tags = new ArrayList<>();
- TaxonName<?, INameCacheStrategy> name = CdmBase.deproxy(taxonBase.getName());
+ TaxonName name = CdmBase.deproxy(taxonBase.getName());
if (name != null){
INameCacheStrategy nameCacheStrategy = name.getCacheStrategy();
//compare accepted against synonyms
for (Synonym synonym: synonyms){
- TaxonName<?, ?> basionym = compareHomotypic(taxon.getName(), synonym.getName());
+ TaxonName basionym = compareHomotypic(taxon.getName(), synonym.getName());
if (basionym != null){
synonym.setType(SynonymType.HOMOTYPIC_SYNONYM_OF());
adaptHomotypicGroup(basionym, taxon.getName(), synonym.getName());
for (int j = i + 1; j < synonymList.size(); j++){
Synonym syn1 = synonymList.get(i);
Synonym syn2 = synonymList.get(j);
- TaxonName<?, ?> basionym = compareHomotypic(syn1.getName(), syn2.getName());
+ TaxonName basionym = compareHomotypic(syn1.getName(), syn2.getName());
if (basionym != null){
adaptHomotypicGroup(basionym, syn1.getName(), syn2.getName());
if (taxon.getName().getBasionyms().contains(basionym)){
* @param name
* @param name2
*/
- private void adaptHomotypicGroup(TaxonName<?, ?> basionym,
- TaxonName<?,?> name1, TaxonName<?,?> name2) {
+ private void adaptHomotypicGroup(TaxonName basionym,
+ TaxonName name1, TaxonName name2) {
if (basionym.equals(name1)){
if (!name2.getBasionyms().contains(name1)){
name2.addBasionym(name1);
* @param name
* @param name2
*/
- private TaxonName<?,?> compareHomotypic(TaxonName<?,?> name1, TaxonName<?,?> name2) {
+ private TaxonName compareHomotypic(TaxonName name1, TaxonName name2) {
if (name1 == null || name2 == null){
return null;
}
- TaxonName<?,?> basionymCandidate = checkAuthors(name1, name2);
+ TaxonName basionymCandidate = checkAuthors(name1, name2);
if (basionymCandidate == null){
return null;
}else{
- TaxonName<?,?> newCombinationCandidate
+ TaxonName newCombinationCandidate
= basionymCandidate == name1? name2: name1;
boolean isBasionym = compareNameParts(basionymCandidate, newCombinationCandidate);
if (isBasionym){
* @param basionymCandiate
* @param newCombinationCandidate
*/
- private boolean compareNameParts(TaxonName<?, ?> basionymCandidate,
- TaxonName<?, ?> newCombinationCandidate) {
+ private boolean compareNameParts(TaxonName basionymCandidate,
+ TaxonName newCombinationCandidate) {
if (basionymCandidate.isGenusOrSupraGeneric() || newCombinationCandidate.isGenusOrSupraGeneric()){
return false;
}else if (matchLastNamePart(basionymCandidate, newCombinationCandidate)){
* @param name2
* @return
*/
- private TaxonName<?,?> checkAuthors(TaxonName<?, ?> name1, TaxonName<?, ?> name2) {
+ private TaxonName checkAuthors(TaxonName name1, TaxonName name2) {
if (hasBasionymAuthorOf(name1, name2)){
return name1;
}else if (hasBasionymAuthorOf(name2, name1)){
* @param name2
* @return
*/
- private boolean hasBasionymAuthorOf(TaxonName<?,?> name1, TaxonName<?,?> name2) {
+ private boolean hasBasionymAuthorOf(TaxonName name1, TaxonName name2) {
TeamOrPersonBase<?> basAuthor2 = name2.getBasionymAuthorship();
TeamOrPersonBase<?> combinationAuthor = name1.getCombinationAuthorship();
TeamOrPersonBase<?> basAuthor1 = name1.getBasionymAuthorship();
* @param newCombination
* @return
*/
- public static boolean matchLastNamePart(TaxonName<?,?> name1, TaxonName<?,?> name2) {
+ public static boolean matchLastNamePart(TaxonName name1, TaxonName name2) {
String lastNamePart1 = name1.getLastNamePart();
String lastNamePart2 = name2.getLastNamePart();
if (lastNamePart1 != null && lastNamePart2 != null){
public boolean isValid(NameRelationship nameRelationship, ConstraintValidatorContext constraintContext) {
boolean valid = true;
if(nameRelationship.getType() != null && nameRelationship.getType().equals(NameRelationshipType.BASIONYM())) {
- TaxonName<?,?> from = CdmBase.deproxy(nameRelationship.getFromName(), TaxonName.class);
- TaxonName<?,?> to = CdmBase.deproxy(nameRelationship.getToName(), TaxonName.class);
+ TaxonName from = CdmBase.deproxy(nameRelationship.getFromName(), TaxonName.class);
+ TaxonName to = CdmBase.deproxy(nameRelationship.getToName(), TaxonName.class);
if(from.isNonViral() && to.isNonViral()) {
INonViralName fromName = from;
Taxon child = taxonNode.getTaxon();\r
\r
if (parent != null && child != null && parent.getName() != null && child.getName() != null){\r
- TaxonName<?,?> parentNameBase = CdmBase.deproxy(parent.getName(), TaxonName.class);\r
- TaxonName<?,?> childNameBase = CdmBase.deproxy(child.getName(), TaxonName.class);\r
+ TaxonName parentNameBase = CdmBase.deproxy(parent.getName(), TaxonName.class);\r
+ TaxonName childNameBase = CdmBase.deproxy(child.getName(), TaxonName.class);\r
if(parentNameBase.isNonViral() && childNameBase.isNonViral()) {\r
INonViralName parentName = parentNameBase;\r
INonViralName childName = childNameBase;\r
*
*/
public class NameMustFollowCodeValidator implements
- ConstraintValidator<NameMustFollowCode, TaxonName<?,?>> {
+ ConstraintValidator<NameMustFollowCode, TaxonName> {
@Override
public void initialize(NameMustFollowCode nameMustFollowTheirCode) { }
@Override
- public boolean isValid(TaxonName<?,?> name, ConstraintValidatorContext constraintContext) {
+ public boolean isValid(TaxonName name, ConstraintValidatorContext constraintContext) {
name = CdmBase.deproxy(name);
boolean valid = true;
@Test
public void testPropertyChange() {
INonViralName b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- ((TaxonName<?,?>)b).addPropertyChangeListener(this);
+ ((TaxonName)b).addPropertyChangeListener(this);
b.setGenusOrUninomial("Abies");
assertEquals(b.getGenusOrUninomial(), lastPropValue);
b.setGenusOrUninomial("Picea");
}
- private class TaxonNameTestClass extends TaxonName<TaxonNameTestClass, INameCacheStrategy>{
+ private class TaxonNameTestClass extends TaxonName{
public TaxonNameTestClass(Rank rank, HomotypicalGroup hg){super(null, rank, hg);}
@Override
public void setCacheStrategy(INameCacheStrategy strategy){}
description.addElement(textData);
//CLONE
- TaxonName<?,?> clone = (TaxonName)taxonName1.clone();
+ TaxonName clone = (TaxonName)taxonName1.clone();
TaxonName genusClone = (TaxonName)genusName.clone();
assertSame("Rank should be same", taxonName1.getRank(), clone.getRank());
assertTrue("TaxonBases should not be cloned", clone.getTaxonBases().isEmpty());
private static Taxon taxon3;
private static Taxon taxon12;
private static Taxon taxon121;
- private static TaxonName<?,?> taxonName1;
- private static TaxonName<?,?> taxonName2;
- private static TaxonName<?,?> taxonName3;
- private static TaxonName<?,?> taxonName12;
- private static TaxonName<?,?> taxonName121;
+ private static TaxonName taxonName1;
+ private static TaxonName taxonName2;
+ private static TaxonName taxonName3;
+ private static TaxonName taxonName12;
+ private static TaxonName taxonName121;
private static Reference ref1;
private static Reference ref2;
private static Reference ref3;
*/
@Test
public void testAddRoot() {
- TaxonName<?,?> synonymName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName synonymName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
Synonym synonym = Synonym.NewInstance(synonymName, ref1);
TaxonNode taxonNode1 = classification1.addChildTaxon(taxon1, null, null);
taxonNode1.setSynonymToBeUsed(synonym);
@Test
public void testAddParentChild() {
- TaxonName<?,?> synonymName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName synonymName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
Synonym synonym = Synonym.NewInstance(synonymName, ref1);
TaxonNode rootNode = classification1.addChildTaxon(taxon1, null, null);
rootNode.setSynonymToBeUsed(synonym);
//genericDao.getCdmBasesByFieldAndClass(clazz, field.getName(), value);
- TaxonName<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
name.setTitleCache("A dummy name", true);
result.add(name);
Reference ref = ReferenceFactory.newBook();
@Test\r
public void testCompareTo() {\r
\r
- TaxonName<?,?> abies = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);\r
+ TaxonName abies = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);\r
abies.setNameCache("Abies");\r
abies.setTitleCache("Abies", true);\r
Reference sec = ReferenceFactory.newArticle();\r
@Test
public void testOriginalSpelling() {
NameRelationshipType origSpellingType = NameRelationshipType.ORIGINAL_SPELLING();
- TaxonName originalName = (TaxonName<?,?>)speciesName.clone();
+ TaxonName originalName = (TaxonName)speciesName.clone();
originalName.setSpecificEpithet("alpa");
Assert.assertEquals("Preconditions are wrong", "Abies alpa", originalName.getTitleCache());
Assert.assertEquals("Name cache should not show original spelling", "Abies alpa", originalName.getNameCache());
//#3665
INonViralName correctName = NonViralNameParserImpl.NewInstance().parseFullName("Nepenthes glabrata J.R.Turnbull & A.T.Middleton");
- TaxonName originalSpelling = (TaxonName<?,?>)NonViralNameParserImpl.NewInstance().parseFullName("Nepenthes glabratus");
+ TaxonName originalSpelling = (TaxonName)NonViralNameParserImpl.NewInstance().parseFullName("Nepenthes glabratus");
correctName.addRelationshipFromName(originalSpelling, origSpellingType, null);
Assert.assertEquals("Nepenthes glabrata", correctName.getNameCache());
Assert.assertEquals("Nepenthes glabrata J.R.Turnbull & A.T.Middleton", correctName.getTitleCache());
private Synonym synonym1;
private Synonym synonym2;
private Synonym synonym3;
- private TaxonName<?,?> accName1;
- private TaxonName<?,?> synName1;
- private TaxonName<?,?> synName2;
- private TaxonName<?,?> synName3;
+ private TaxonName accName1;
+ private TaxonName synName1;
+ private TaxonName synName2;
+ private TaxonName synName3;
private Person person1;
private Person person2;
private Person person3;
@Test
public void testValidEmptyNames() {
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations
+ Set<ConstraintViolation<TaxonName>> constraintViolations
= validator.validate(cultivarName);
assertTrue("There should be no constraint violations as this name has data set and therefore no unvalid attributes set", constraintViolations.isEmpty());
@Test
public void testMessage() {
nonViralName.setAcronym("acronym");
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations = validator.validate(nonViralName);
+ Set<ConstraintViolation<TaxonName>> constraintViolations = validator.validate(nonViralName);
assertFalse("There should be a constraint violation as a nonViralName must not have an acronym", constraintViolations.isEmpty());
String message = constraintViolations.iterator().next().getMessage();
String expected = "Taxon name must only have attributes set that are available according to their code. E.g. 'acronym name' should only be available for viral names.";
@Test
public void testValidNonViralName() {
nonViralName.setAcronym("acronym");
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations = validator.validate(nonViralName);
+ Set<ConstraintViolation<TaxonName>> constraintViolations = validator.validate(nonViralName);
assertFalse("There should be a constraint violation as a nonViralName must not have an acronym", constraintViolations.isEmpty());
nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
@Test
public void testValidViralName() {
viralName.setAcronym("acronym");
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations = validator.validate(viralName);
+ Set<ConstraintViolation<TaxonName>> constraintViolations = validator.validate(viralName);
assertTrue("There should be no constraint violation as a viral name may have acronym set", constraintViolations.isEmpty());
//Invalid
zoologicalName.setOriginalPublicationYear(1987);
zoologicalName.setPublicationYear(2001);
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations = validator.validate(zoologicalName);
+ Set<ConstraintViolation<TaxonName>> constraintViolations = validator.validate(zoologicalName);
assertTrue("There should be no constraint violation as a zoological name may have breed and years set", constraintViolations.isEmpty());
}
bacterialName.setSubGenusAuthorship("Subgenus author");
bacterialName.setNameApprobation("Name approbation");
- Set<ConstraintViolation<TaxonName<?,?>>> constraintViolations = validator.validate(bacterialName);
+ Set<ConstraintViolation<TaxonName>> constraintViolations = validator.validate(bacterialName);
assertTrue("There should be no constraint violation as a bacterial name may have subgenus authorship or name approbation set", constraintViolations.isEmpty());
}
//TODO cast
getCollectionRoles(clazz, sessionFactory);
- TaxonName<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(null);
name1.getTaxonBases();
Type propType = sessionFactory.getReferencedPropertyType(TaxonName.class.getCanonicalName(), "taxonBases");
}
- public List<TaxonName<?,?>> searchNames(String queryString, MatchMode matchMode, Integer pageSize, Integer pageNumber) {
+ public List<TaxonName> searchNames(String queryString, MatchMode matchMode, Integer pageSize, Integer pageNumber) {
checkNotInPriorView("TaxonNameDaoHibernateImpl.searchNames(String queryString, Integer pageSize, Integer pageNumber)");
Criteria criteria = getSession().createCriteria(TaxonName.class);
criteria.setFirstResult(0);
}
}
- List<TaxonName<?,?>> results = criteria.list();
+ List<TaxonName> results = criteria.list();
return results;
}
@Override
- public List<TaxonName<?,?>> searchNames(String queryString, Integer pageSize, Integer pageNumber) {
+ public List<TaxonName> searchNames(String queryString, Integer pageSize, Integer pageNumber) {
return searchNames(queryString, MatchMode.BEGINNING, pageSize, pageNumber);
}
}
@Override
- public List<? extends TaxonName<?,?>> findByName(boolean doIncludeAuthors,
+ public List<? extends TaxonName> findByName(boolean doIncludeAuthors,
String queryString, MatchMode matchmode, Integer pageSize,
Integer pageNumber, List<Criterion> criteria, List<String> propertyPaths) {
}
@SuppressWarnings("unchecked")
- List<? extends TaxonName<?,?>> results = crit.list();
+ List<? extends TaxonName> results = crit.list();
defaultBeanInitializer.initializeAll(results, propertyPaths);
return results;
}
@Override
- public List<? extends TaxonName<?,?>> findByTitle(String queryString,
+ public List<? extends TaxonName> findByTitle(String queryString,
MatchMode matchmode, Integer pageSize, Integer pageNumber, List<Criterion> criteria, List<String> propertyPaths) {
Criteria crit = getSession().createCriteria(type);
}
}
- List<? extends TaxonName<?,?>> results = crit.list();
+ List<? extends TaxonName> results = crit.list();
defaultBeanInitializer.initializeAll(results, propertyPaths);
return results;
}
crit.addOrder(Order.asc("uuid"));
- List<? extends TaxonName<?,?>> results = crit.list();
+ List<? extends TaxonName> results = crit.list();
if (results.size() == 1) {
defaultBeanInitializer.initializeAll(results, propertyPaths);
- TaxonName<?, ?> taxonName = results.iterator().next();
+ TaxonName taxonName = results.iterator().next();
return taxonName;
} else if (results.size() > 1) {
logger.error("Multiple results for UUID: " + uuid);
public Integer countByName(String queryString, MatchMode matchmode, List<Criterion> criteria) {
//TODO improve performance
boolean includeAuthors = false;
- List<? extends TaxonName<?,?>> results = findByName(
+ List<? extends TaxonName> results = findByName(
includeAuthors,queryString, matchmode, null, null, criteria, null);
return results.size();
}
@SuppressWarnings("unchecked")
- List<? extends TaxonName<?,?>> results = criteria.list();
+ List<? extends TaxonName> results = criteria.list();
if (results.size() == 1) {
defaultBeanInitializer.initializeAll(results, null);
- TaxonName<?, ?> taxonName = results.iterator().next();
+ TaxonName taxonName = results.iterator().next();
if (taxonName.isZoological()) {
IZoologicalName zoologicalName = taxonName;
return zoologicalName;
import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
+import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.LSID;
import eu.etaxonomy.cdm.model.common.MarkerType;
-import eu.etaxonomy.cdm.model.common.OriginalSourceBase;
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.name.Rank;
boolean includeAuthors = false;
List<UuidAndTitleCache<IdentifiableEntity>> resultObjects = new ArrayList<UuidAndTitleCache<IdentifiableEntity>>();
if (doNamesWithoutTaxa){
- List<? extends TaxonName<?,?>> nameResult = taxonNameDao.findByName(
+ List<? extends TaxonName> nameResult = taxonNameDao.findByName(
includeAuthors, queryString, matchMode, null, null, null, null);
for (TaxonName name: nameResult){
query = getSession().createQuery("from ZoologicalName zn where zn.nameCache IN (:identicalNames)");
query.setParameterList("identicalNames", identicalNames);
List<TaxonName> result = query.list();
- TaxonName temp = result.get(0);
+ TaxonName tempName = result.get(0);
- Iterator<OriginalSourceBase> sources = temp.getSources().iterator();
+ Iterator<IdentifiableSource> sources = tempName.getSources().iterator();
TaxonNameComparator taxComp = new TaxonNameComparator();
Collections.sort(result, taxComp);
}
} else if(bean instanceof TaxonName) {
// ---> TaxonName
- TaxonName n = (TaxonName<?,?>)bean;
+ TaxonName n = (TaxonName)bean;
if(!n.isProtectedFullTitleCache()) {
n.getFullTitleCache();
} else if(!bean.isProtectedTitleCache()){
* set (0 - based)\r
* @return a List of TaxonName instances\r
*/\r
- public List<TaxonName<?, ?>> searchNames(String queryString,\r
+ public List<TaxonName> searchNames(String queryString,\r
Integer pageSize, Integer pageNumber);\r
\r
\r
* @param propertyPaths TODO\r
* @return\r
*/\r
- public List<? extends TaxonName<?, ?>> findByName(boolean doIncludeAuthors,\r
+ public List<? extends TaxonName> findByName(boolean doIncludeAuthors,\r
String queryString,\r
MatchMode matchmode, Integer pageSize, Integer pageNumber,\r
List<Criterion> criteria, List<String> propertyPaths);\r
* @param propertyPaths TODO\r
* @return\r
*/\r
- public List<? extends TaxonName<?, ?>> findByTitle(String queryString,\r
+ public List<? extends TaxonName> findByTitle(String queryString,\r
MatchMode matchmode, Integer pageSize, Integer pageNumber,\r
List<Criterion> criteria, List<String> propertyPaths);\r
\r
*\r
* @return\r
*/\r
- public TaxonName<?, ?> findByUuid(UUID uuid, List<Criterion> criteria, List<String> propertyPaths);\r
+ public TaxonName findByUuid(UUID uuid, List<Criterion> criteria, List<String> propertyPaths);\r
\r
/**\r
* @param queryString\r
propertyPaths.add("combinationAuthorship");
propertyPaths.add("hybridRelationships");
- TaxonName<?,?> sphingidae = taxonNameDao.load(sphingidaeUuid, propertyPaths);
+ TaxonName sphingidae = taxonNameDao.load(sphingidaeUuid, propertyPaths);
setComplete();
endTransaction();
// @Ignore
public void testMergeCdmBaseReferenceAndIdentifiable() throws MergeException {
- TaxonName<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
- TaxonName<?,?> name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("BotanicalName2", true);
TaxonName zooName1 = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
@Test
// @Ignore
public void testMergeTaxonNameAndTaxon() throws MergeException {
- TaxonName<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
- TaxonName<?,?> name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("BotanicalName2", true);
IBotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
UUID uuidAbiesAlba = UUID.fromString("6ed56b43-7cca-4c3b-bb90-7576da81c072");
// CREATE DATA
- TaxonName<?,?> pinusAlba = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName pinusAlba = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
pinusAlba.setTitleCache("BotanicalName1", true);
pinusAlba.setUuid(uuidPinusAlba);
- TaxonName<?,?> abiesAlba = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName abiesAlba = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
abiesAlba.setTitleCache("Abies alba", true);
abiesAlba.setUuid(uuidAbiesAlba);
@Test
public void testReallocatePersonTeam() throws MergeException {
- TaxonName<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
IBook book1 = ReferenceFactory.newBook();
@ExpectedDataSet
public void testOnSaveOrUpdateNames() {
//names
- TaxonName<?,?> name = cdmEntityDaoBase.findByUuid(UUID.fromString("a49a3963-c4ea-4047-8588-2f8f15352730"));
+ TaxonName name = cdmEntityDaoBase.findByUuid(UUID.fromString("a49a3963-c4ea-4047-8588-2f8f15352730"));
name.setTitleCache(null, false);
name.setNameCache(null, false);
name.setGenusOrUninomial("Abies");
name.setAuthorshipCache("Mill.", true);
cdmEntityDaoBase.saveOrUpdate(name);
- TaxonName<?,?> name2 = cdmEntityDaoBase.findByUuid(UUID.fromString("05a438d6-065f-49ef-84db-c7dc2c259975"));
+ TaxonName name2 = cdmEntityDaoBase.findByUuid(UUID.fromString("05a438d6-065f-49ef-84db-c7dc2c259975"));
name2.setProtectedFullTitleCache(false);
name2.setProtectedTitleCache(false);
name2.setProtectedNameCache(false);
Assert.assertEquals(name2, cdmEntityDaoBase.findByUuid(name2.getUuid()));
logger.debug("FulltitleCache: "+ cdmEntityDaoBase.findByUuid(name2.getUuid()).getFullTitleCache());
logger.debug("updated: " + cdmEntityDaoBase.findByUuid(name2.getUuid()).getUpdated());
- TaxonName<?,?> name3 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonName name3 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
name3.setFullTitleCache("Test: MyBook");
name3.setTitleCache("Test", true);
cdmEntityDaoBase.saveOrUpdate(name3);
List<TaxonName> taxa = cdmEntityDaoBase.findByTitle("Test");
- TaxonName<?,?> nameBase = taxa.get (0);
+ TaxonName nameBase = taxa.get (0);
IBotanicalName botName = nameBase;
logger.debug("created "+botName.getCreated());
@DataSet("CdmDeleteListenerTest.xml")
@ExpectedDataSet
public void testOnDelete() throws Exception {
- TaxonName<?,?> name = taxonNameDao.findByUuid(uuid);
+ TaxonName name = taxonNameDao.findByUuid(uuid);
/**
* Ended up with some horrible hibernate errors otherwise
*/
if(parentNode == null){
//if no match found in list, create parentNode
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
- TaxonName<?,?> TaxonName = (TaxonName<?,?>)parser.parseFullName(genus);
+ TaxonName TaxonName = (TaxonName)parser.parseFullName(genus);
//TODO Sec via configurator
Taxon taxon = Taxon.NewInstance(TaxonName, null);
parentNode = newClassification.addChildTaxon(taxon, 0, null, null);
}
result.setTaxonLabel(taxonBase.getTitleCache());
- TaxonName<?,?> name = taxonBase.getName();
+ TaxonName name = taxonBase.getName();
result.setNameUuid(name.getUuid());
result.setNameLabel(name.getTitleCache());
result.setNameWithoutAuthor(name.getNameCache());
if (entity.getTitleCache() != null){
//System.err.println(entity.getTitleCache());
}else{
- //System.err.println("no titleCache" + ((TaxonName<?,?>)entity).getNameCache());
+ //System.err.println("no titleCache" + ((TaxonName)entity).getNameCache());
}
}
saveOrUpdate(entitiesToUpdate);
* @param name
* @param config
*/
- private void removeNameRelationshipsByDeleteConfig(TaxonName<?,?> name, NameDeletionConfigurator config) {
+ private void removeNameRelationshipsByDeleteConfig(TaxonName name, NameDeletionConfigurator config) {
try {
if (config.isRemoveAllNameRelationships()){
Set<NameRelationship> rels = getModifiableSet(name.getNameRelations());
associatedTaxa.add(determinationEvent.getTaxon());
}
if(determinationEvent.getTaxonName()!=null){
- associatedTaxa.addAll(determinationEvent.getTaxonName().getTaxonBases());
+ associatedTaxa.addAll((Collection)determinationEvent.getTaxonName().getTaxonBases());
}
}
}
if (synonym == null){
return null;
}
- TaxonName<?, ?> synonymName = synonym.getName();
+ TaxonName synonymName = synonym.getName();
/* // remove synonym from taxon
toTaxon.removeSynonym(synonym);
if (configurator.isDoNamesWithoutTaxa()) {
int numberNameResults = 0;
- List<? extends TaxonName<?,?>> names =
+ List<? extends TaxonName> names =
nameDao.findByName(configurator.isDoIncludeAuthors(), configurator.getTitleSearchStringSqlized(), configurator.getMatchMode(),
configurator.getPageSize(), configurator.getPageNumber(), null, configurator.getTaxonNamePropertyPath());
if (logger.isDebugEnabled()) { logger.debug(names.size() + " matching name(s) found"); }
if (names.size() > 0) {
- for (TaxonName<?,?> taxonName : names) {
+ for (TaxonName taxonName : names) {
if (taxonName.getTaxonBases().size() == 0) {
results.add(taxonName);
numberNameResults++;
UpdateResult result = new UpdateResult();
// Create new synonym using concept name
- TaxonName<?, ?> synonymName = fromTaxon.getName();
+ TaxonName synonymName = fromTaxon.getName();
// Remove concept relation from taxon
toTaxon.removeTaxon(fromTaxon, oldRelationshipType);
import eu.etaxonomy.cdm.validation.annotation.NoDuplicateNames;
public class NoDuplicateNamesValidator implements
- ConstraintValidator<NoDuplicateNames,TaxonName<?,?>> {
+ ConstraintValidator<NoDuplicateNames,TaxonName> {
private static Set<String> includeProperties;
public void initialize(NoDuplicateNames noDuplicateNames) { }
@Override
- public boolean isValid(TaxonName<?,?> name, ConstraintValidatorContext constraintContext) {
+ public boolean isValid(TaxonName name, ConstraintValidatorContext constraintContext) {
if(name == null) {
return true;
} else {
private final String exsiccatum = "Greuter, Pl. Dahlem. 456";
private final String accessionNumber = "8909756";
private final String catalogNumber = "UU879873590";
- private final TaxonName<?,?> taxonName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS(), "Abies", null, null, null, null, null, null, null);
+ private final TaxonName taxonName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS(), "Abies", null, null, null, null, null, null, null);
private final String collectorsNumber = "234589913A34";
private final Collection collection = Collection.NewInstance();
String accessionNumber = "8909756";
String catalogNumber = "UU879873590";
String barcode = "B12345678";
- TaxonName<?,?> taxonName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS(), "Abies", null, null, null, null, null, null, null);
+ TaxonName taxonName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS(), "Abies", null, null, null, null, null, null, null);
String collectorsNumber = "234589913A34";
Collection collection = Collection.NewInstance();
person.setNomenclaturalTitle(nomTitle);
Annotation annotation = Annotation.NewDefaultLanguageInstance("Meine annotation");
person.setContact(getContact());
- TaxonName<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setCombinationAuthorship(person);
person.addAnnotation(annotation);
Annotation annotation = Annotation.NewDefaultLanguageInstance("Meine annotation");
team.addAnnotation(annotation);
team.setContact(getContact());
- TaxonName<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setCombinationAuthorship(team);
service.save(team);
Annotation annotation2 = Annotation.NewDefaultLanguageInstance("Meine annotation2");
team.addAnnotation(annotation2);
team.setContact(getContact());
- TaxonName<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setCombinationAuthorship(team);
Person member = Person.NewTitledInstance("Member person");
member.setNomenclaturalTitle("Memb. pers.");
Map<String, Taxon> map = new HashMap<String, Taxon>();
for(String strName : stringTaxonNames){
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
- TaxonName<?,?> nameBase = (TaxonName<?,?>)parser.parseFullName(strName);
+ TaxonName nameBase = (TaxonName)parser.parseFullName(strName);
Taxon taxon = Taxon.NewInstance(nameBase, null);
map.put(strName, taxon);
}
final String[] tableNames = new String[]{"USERACCOUNT", "TaxonName","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
// printDataSetWithNull(System.err, true, null);
- TaxonName<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
- TaxonName<?,?> nameWithBasionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonName nameWithBasionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
nameWithBasionym.setTitleCache("nameWithBasionym", true);
NameRelationshipType nameRelType = (NameRelationshipType)termService.find(NameRelationshipType.BASIONYM().getUuid());
TaxonName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name used as type", true);
- TaxonName<?,?> higherName = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
+ TaxonName higherName = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
higherName.setTitleCache("genus name", true);
NameTypeDesignationStatus typeStatus = (NameTypeDesignationStatus)termService.find(NameTypeDesignationStatus.AUTOMATIC().getUuid());
boolean addToAllHomotypicNames = true;
private Taxon getTaxon() {
Reference sec = getReference();
- TaxonName<?, ?> name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonName name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
Taxon taxon = Taxon.NewInstance(name, sec);
return taxon;
CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds);
Person agent = Person.NewInstance();
appCtr.getAgentService().save(agent);
- TaxonName<?,?> tn = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonName tn = TaxonNameFactory.NewBotanicalInstance(null);
appCtr.getNameService().save(tn);
appCtr.close();
CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds);
Person agent = Person.NewInstance();
appCtr.getAgentService().save(agent);
- TaxonName<?,?> tn = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonName tn = TaxonNameFactory.NewBotanicalInstance(null);
appCtr.getNameService().save(tn);
appCtr.close();
// CdmPersistentDataSource.NewInstance("localH2");
CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds, validation);
try {
- TaxonName<?,?> botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
- TaxonName<?,?> botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
IBotanicalName hybridName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
botName1.addRelationshipToName(botName2, NameRelationshipType.ORTHOGRAPHIC_VARIANT(), null);
UUID uuid1 = botName1.getUuid();
BGBM BDI Projects / cdmlib.git / commitdiff