import eu.etaxonomy.cdm.model.common.OriginalSourceType;
import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationType;
import eu.etaxonomy.cdm.model.reference.Reference;
serviceUrl.getPath()
+ "?" + request);
-
URI newUri = newUrl.toURI();
-
logger.info("Firing request for URI: " + newUri);
-
HttpResponse response = UriUtils.getResponse(newUri, null);
int responseCode = response.getStatusLine().getStatusCode();
}
- private List<BotanicalName> buildNameList( InputStream content, ICdmApplicationConfiguration appConfig, IIpniServiceConfigurator iConfig) throws IOException {
+ private List<TaxonNameBase<?,?>> buildNameList( InputStream content, ICdmApplicationConfiguration appConfig, IIpniServiceConfigurator iConfig) throws IOException {
IpniServiceNamesConfigurator config = (IpniServiceNamesConfigurator)iConfig;
- List<BotanicalName> result = new ArrayList<BotanicalName>();
+ List<TaxonNameBase<?,?>> result = new ArrayList<>();
BufferedReader reader = new BufferedReader (new InputStreamReader(content));
String headerLine = reader.readLine();
String line = reader.readLine();
while (StringUtils.isNotBlank(line)){
- BotanicalName name = getNameFromLine(line,parameterMap, appConfig);
+ TaxonNameBase<?,?> name = (TaxonNameBase<?,?>)getNameFromLine(line,parameterMap, appConfig);
result.add(name);
line = reader.readLine();
}
- private BotanicalName getNameFromLine(String line, Map<Integer, String> parameterMap, ICdmApplicationConfiguration appConfig) {
+ private IBotanicalName getNameFromLine(String line, Map<Integer, String> parameterMap, ICdmApplicationConfiguration appConfig) {
//Id%Version%Standard form%Default author forename%Default author surname%Taxon groups%Dates%Alternative names
String[] splits = line.split("%");
Map<String, String> valueMap = new HashMap<String, String>();
valueMap.put(parameterMap.get(i), splits[i]);
}
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(null);
//caches
name.setNameCache(valueMap.get(FULL_NAME_WITHOUT_FAMILY_AND_AUTHORS), true);
name.addAnnotation(annotation);
//basionym
- BotanicalName basionym = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonNameBase<?,?> basionym = TaxonNameFactory.NewBotanicalInstance(null);
basionym.setTitleCache(valueMap.get(BASIONYM), true);
name.addBasionym(basionym);
//replaced synonym
- BotanicalName replacedSynoynm = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonNameBase<?,?> replacedSynoynm = TaxonNameFactory.NewBotanicalInstance(null);
replacedSynoynm.setTitleCache(valueMap.get(REPLACED_SYNONYM), true);
name.addReplacedSynonym(replacedSynoynm, null, null, null);
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.common.Extension;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.reference.Reference;
if (testInternetConnectivity(nameList)){
Assert.assertEquals("There should be exactly 1 result for 'Abies albertiana'", 1, nameList.size());
- BotanicalName name = nameList.get(0);
+ IBotanicalName name = nameList.get(0);
//title cache
Assert.assertEquals("Title Cache for Abies albertiana should be 'Abies albertiana'", "Abies albertiana A.Murray bis", name.getTitleCache());
-// for (BotanicalName listName : nameList){
+// for (IBotanicalName listName : nameList){
// System.out.println(name.getFullTitleCache());
// }
}
if (testInternetConnectivity(nameList)){
Assert.assertEquals("There should be exactly 1 result for 'Abies', 'alba', 'B*', Infraspecific ", 1, nameList.size());
- BotanicalName name = nameList.get(0);
+ IBotanicalName name = nameList.get(0);
//title cache
Assert.assertEquals("Title Cache for 'Abies', 'alba', 'ap*' should be 'Abies alba subsp. apennina Brullo, Scelsi & Spamp.'", "Abies alba subsp. apennina Brullo, Scelsi & Spamp.", name.getTitleCache());
- // for (BotanicalName listName : nameList){
+ // for (IBotanicalName listName : nameList){
// System.out.println(name.getFullTitleCache());
// }
}
import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.ExtensionType;
+import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.common.IOriginalSource;
import eu.etaxonomy.cdm.model.common.ISourceable;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
* @param citation
* @throws SQLException
*/
- public void addOriginalSource(CdmBase cdmBase, Object idAttributeValue, String namespace, Reference citation) {
+ public void addOriginalSource(ICdmBase cdmBase, Object idAttributeValue, String namespace, Reference citation) {
if (cdmBase instanceof ISourceable ){
IOriginalSource source;
ISourceable sourceable = (ISourceable<?>)cdmBase;
import eu.etaxonomy.cdm.model.common.AnnotatableEntity;\r
import eu.etaxonomy.cdm.model.common.Annotation;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
+import eu.etaxonomy.cdm.model.common.ICdmBase;\r
import eu.etaxonomy.cdm.model.common.IOriginalSource;\r
import eu.etaxonomy.cdm.model.common.ISourceable;\r
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;\r
// return addValue(rs, cdmBase, dbAttrName, cdmAttrName, String.class, overwriteNull);\r
// }\r
\r
- public static boolean addBooleanValue(ResultSet rs, CdmBase cdmBase, String dbAttrName, String cdmAttrName){\r
+ public static boolean addBooleanValue(ResultSet rs, ICdmBase cdmBase, String dbAttrName, String cdmAttrName){\r
return addValue(rs, cdmBase, dbAttrName, cdmAttrName, boolean.class, OVERWRITE, false);\r
}\r
\r
- public static boolean addValue(ResultSet rs, CdmBase cdmBase, String dbAttrName, String cdmAttrName, Class clazz, boolean overwriteNull, boolean blankToNull){\r
+ public static boolean addValue(ResultSet rs, ICdmBase cdmBase, String dbAttrName, String cdmAttrName, Class clazz, boolean overwriteNull, boolean blankToNull){\r
Object strValue;\r
try {\r
strValue = rs.getObject(dbAttrName);\r
return addValue(strValue, cdmBase, cdmAttrName, clazz, overwriteNull, obligat);\r
}\r
\r
- public static boolean addValue(Object sourceValue, CdmBase cdmBase, String cdmAttrName, Class<?> clazz, boolean overwriteNull, boolean obligat){\r
+ public static boolean addValue(Object sourceValue, ICdmBase cdmBase, String cdmAttrName, Class<?> clazz, boolean overwriteNull, boolean obligat){\r
String methodName;\r
// Object strValue;\r
try {\r
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.HomotypicalGroupComparator;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
- private String createSynonymNameString(BotanicalName synonymName, boolean isInvalid) {
+ private String createSynonymNameString(IBotanicalName synonymName, boolean isInvalid) {
String synonymString = null;
synonymString= createTaggedNameString(synonymName, isInvalid);
String strScientificName = getValue(item, TermUri.DWC_SCIENTIFIC_NAME);
//Name
if (strScientificName != null){
- name = parser.parseFullName(strScientificName, nomCode, rank);
+ name = (TaxonNameBase<?,?>)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(TaxonNameBase nameBase, StreamItem item) {
+ private void checkAuthorship(TaxonNameBase<?,?> nameBase, StreamItem item) {
if (!nameBase.isInstanceOf(NonViralName.class)){
return;
}
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.description.TextData;\r
import eu.etaxonomy.cdm.model.name.INonViralName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
Integer combYear = null;\r
Integer origYear = null;\r
if (nvn.isInstanceOf(ZoologicalName.class)){\r
- ZoologicalName zooName = CdmBase.deproxy(nvn, ZoologicalName.class);\r
+ IZoologicalName zooName = CdmBase.deproxy(nvn, ZoologicalName.class);\r
combYear = zooName.getPublicationYear();\r
origYear = zooName.getOriginalPublicationYear();\r
}\r
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.CultivarPlantName;
import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
protected TaxonNameBase<?, ?> getOrCreateTaxonName(String scientificName, Rank rank, boolean preferredFlag, STATE state, int unitIndexInAbcdFile){
- TaxonNameBase<?, ?> taxonName = null;
+ TaxonNameBase<?,?> taxonName = null;
SpecimenImportConfiguratorBase<?,?> config = state.getConfig();
//check atomised name data for rank
if(config.isReuseExistingTaxaWhenPossible()){
TaxonNameBase<?,?> parsedName = atomisedTaxonName;
if(parsedName==null){
- parsedName = parseScientificName(scientificName, state, state.getReport());
+ parsedName = (TaxonNameBase<?,?>)parseScientificName(scientificName, state, state.getReport());
}
atomisedTaxonName = parsedName;
if(config.isIgnoreAuthorship() && parsedName!=null && preferredFlag){
// do not ignore authorship for non-preferred names because they need
// to be created for the determination history
- String nameCache = parsedName.getNameCache();
+ String nameCache = TaxonNameBase.castAndDeproxy(parsedName).getNameCache();
List<NonViralName> names = getNameService().findNamesByNameCache(nameCache, MatchMode.EXACT, null);
if (!names.isEmpty()){
return getBestMatchingName(scientificName, new ArrayList<TaxonNameBase>(names), state);
* @param report the import report
* @return a parsed name
*/
- protected TaxonNameBase<?,?> parseScientificName(String scientificName, STATE state, SpecimenImportReport report) {
+ protected ITaxonNameBase parseScientificName(String scientificName, STATE state, SpecimenImportReport report) {
NonViralNameParserImpl nvnpi = NonViralNameParserImpl.NewInstance();
- TaxonNameBase<?,?> taxonName = null;
+ ITaxonNameBase taxonName = null;
boolean problem = false;
if(DEBUG){
import eu.etaxonomy.cdm.model.location.NamedAreaType;
import eu.etaxonomy.cdm.model.location.ReferenceSystem;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NonViralName;
if (StringUtils.isNotBlank(commonDetermination.determinedBy)){
sec = ReferenceFactory.newGeneric();
TeamOrPersonBase<?> determinedBy;
- BotanicalName dummyName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName dummyName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
try {
parser.parseAuthors(dummyName, commonDetermination.determinedBy);
determinedBy = dummyName.getCombinationAuthorship();
* @param determinationLight
* @return
*/
- private NonViralName<?> makeTaxonName(SpecimenCdmExcelImportState state, DeterminationLight determinationLight) {
- NonViralName<?> name = TaxonNameFactory.NewNonViralInstance(null);
+ private INonViralName makeTaxonName(SpecimenCdmExcelImportState state, DeterminationLight determinationLight) {
+ INonViralName name = TaxonNameFactory.NewNonViralInstance(null);
NomenclaturalCode nc = state.getConfig().getNomenclaturalCode();
if (nc != null){
- name = (NonViralName<?>)nc.getNewTaxonNameInstance(null);
+ name = nc.getNewTaxonNameInstance(null);
}
name.setGenusOrUninomial(determinationLight.genus);
name.setSpecificEpithet(determinationLight.speciesEpi);
private TaxonNameBase findBestMatchingName(SpecimenCdmExcelImportState state, DeterminationLight determinationLight) {
- NonViralName<?> name = makeTaxonName(state, determinationLight);
+ INonViralName name = makeTaxonName(state, determinationLight);
String titleCache = makeSearchNameTitleCache(state, determinationLight, name);
//TODO
}
- private TaxonNameBase<?, ?> getTaxonName(SpecimenCdmExcelImportState state, String name) {
+ private TaxonNameBase<?,?> getTaxonName(SpecimenCdmExcelImportState state, String name) {
TaxonNameBase<?,?> result = null;
result = state.getName(name);
if (result != null){
if (result == null){
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
NomenclaturalCode code = state.getConfig().getNomenclaturalCode();
- result = parser.parseFullName(name, code, null);
+ result = (TaxonNameBase<?,?>)parser.parseFullName(name, code, null);
}
if (result != null){
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.media.Media;
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.occurrence.Collection;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
* @param sec
*/
private void setTaxonNameBase(SpecimenSynthesysExcelImportConfigurator config){
- NonViralName<?> taxonName = null;
+ ITaxonNameBase taxonName = null;
Taxon taxon = null;
String scientificName="";
taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setTitleCache(scientificName, true);
}
- getNameService().save(taxonName);
+ getNameService().save((TaxonNameBase<?,?>)taxonName);
taxon = Taxon.NewInstance(taxonName, ref); //sec set null
getTaxonService().save(taxon);
// refreshTransaction();
return (Taxon) getTaxonService().find(taxon.getUuid());
}
- private NonViralName<?> parseScientificName(String scientificName){
+ private ITaxonNameBase parseScientificName(String scientificName){
if (DEBUG) {
logger.debug("in parseScientificName");
}
NonViralNameParserImpl nvnpi = NonViralNameParserImpl.NewInstance();
- NonViralName<?>taxonName = null;
+ ITaxonNameBase taxonName = null;
boolean problem=false;
if (DEBUG) {
import eu.etaxonomy.cdm.model.description.IndividualsAssociation;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
import eu.etaxonomy.cdm.model.reference.Reference;
* @param refMods
* @param nameToBeFilled
*/
- protected void addSource(Reference refMods, TaxonNameBase<?,?> nameToBeFilled) {
+ protected void addSource(Reference refMods, ITaxonNameBase nameToBeFilled) {
//logger.info("addSource");
sourceUrlRef=CdmBase.deproxy(sourceUrlRef, Reference.class);
Reference sec = CdmBase.deproxy(configState.getConfig().getSecundum(), Reference.class);
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
import eu.etaxonomy.cdm.model.description.TextData;
-import eu.etaxonomy.cdm.model.name.BacterialName;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.ZoologicalName;
}
- private boolean addFollowingTextToName(TaxonNameBase nameToBeFilled, String followingText) {
+ private boolean addFollowingTextToName(ITaxonNameBase nameToBeFilled, String followingText) {
if (nameToBeFilled != null && StringUtils.isNotBlank(followingText)){
if (! followingText.matches("\\d\\.?")){
acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);
NodeList children = refgroup.getChildNodes();
- NonViralName<?> nameToBeFilled = getNonViralNameAccNomenclature();
+ INonViralName nameToBeFilled = getNonViralNameAccNomenclature();
ReferenceBuilder refBuild = new ReferenceBuilder(sourceHandler);
for (int i=0;i<children.getLength();i++){
* @return
*/
- private NonViralName<?> getNonViralNameAccNomenclature() {
- return (NonViralName<?>)nomenclaturalCode.getNewTaxonNameInstance(null);
+ private INonViralName getNonViralNameAccNomenclature() {
+ return nomenclaturalCode.getNewTaxonNameInstance(null);
}
/**
* handle cases where the bibref are inside <p> and outside
*/
@SuppressWarnings("rawtypes")
- private void extractReferenceRawText(NodeList references, NonViralName<?> nameToBeFilled, Reference refMods,
+ private void extractReferenceRawText(NodeList references, INonViralName nameToBeFilled, Reference refMods,
Taxon acceptedTaxon) {
logger.info("extractReferenceRawText");
String refString="";
nameTBF = TaxonNameFactory.NewBotanicalInstance(null);
}
if (nomenclaturalCode.equals(NomenclaturalCode.ICZN)){
- nameTBF = ZoologicalName.NewInstance(null);
+ nameTBF = TaxonNameFactory.NewZoologicalInstance(null);
}
if (nomenclaturalCode.equals(NomenclaturalCode.ICNB)){
- nameTBF= BacterialName.NewInstance(null);
+ nameTBF= TaxonNameFactory.NewBacterialInstance(null);
}
parser.parseReferencedName(nameTBF, fullname, rank, false);
retry++;
// System.out.println("COLLECTION EVENT INSIDE NOMENCLATURE");
extractMaterialsDirect(childNode, acceptedTaxon, refMods, "collection", currentMyName.getTaxonNameBase());
}else if(childName.equalsIgnoreCase("tax:name")){
- NonViralName<?> nameToBeFilled;
+ INonViralName nameToBeFilled;
//System.out.println("HANDLE FIRST NAME OF THE LIST");
if(!containsSynonyms){
wasSynonym = false;
}else if (childName.equalsIgnoreCase("tax:bibref")){
logger.warn(childName + " still preliminary");
- NonViralName<?> currentName = currentMyName == null ? null : currentMyName.getTaxonNameBase();
+ INonViralName currentName = currentMyName == null ? null : currentMyName.getTaxonNameBase();
boolean handled = addFollowingTextToName (currentName, childNode.getTextContent() );
if (! handled){
setParticularDescription(freetext.trim(), acceptedTaxon,acceptedTaxon, refMods, getNotMarkedUpFeatureObject());
}
if(!stringIsEmpty(freetext.trim())) {;
if (! freetext.matches("\\d\\.?")){
- NonViralName<?> currentName = currentMyName == null ? null : currentMyName.getTaxonNameBase();
+ INonViralName currentName = currentMyName == null ? null : currentMyName.getTaxonNameBase();
boolean handled = false;
if (currentName != null && !wasSynonym){
handled = addFollowingTextToName (currentName, childNode.getTextContent() );
nameToBeFilled = TaxonNameFactory.NewBotanicalInstance(null);
}
if (nomenclaturalCode.equals(NomenclaturalCode.ICZN)){
- nameToBeFilled = ZoologicalName.NewInstance(null);
+ nameToBeFilled = TaxonNameFactory.NewZoologicalInstance(null);
}
if (nomenclaturalCode.equals(NomenclaturalCode.ICNB)){
- nameToBeFilled = BacterialName.NewInstance(null);
+ nameToBeFilled = TaxonNameFactory.NewBacterialInstance(null);
}
nameToBeFilled.setTitleCache(s, true);
nameToBeFilled.setRank(getRank(r), true);
private void createUnparsedSynonymNew(Rank rank, String newName, HashMap<String, String> atomisedMap, MyName myname, Reference refMods) {
logger.info("createSynonym");
- NonViralName<?> nameToBeFilled = this.getNonViralNameAccNomenclature();
+ INonViralName nameToBeFilled = this.getNonViralNameAccNomenclature();
//System.out.println("createsynonym");
if(rank.equals(Rank.UNKNOWN_RANK())){
//TODO
classification = classification2;
}
- /**
- * @param tnb
- * cast the current taxonnamebase into a botanical name or zoological or bacterial name
- * if errors, cast into a classis nonviralname
- * @param taxonnamebase2
- */
- @SuppressWarnings("rawtypes")
- public NonViralName<?> castTaxonNameBase(TaxonNameBase tnb, NonViralName<?> nvn) {
-
- //logger.info("castTaxonNameBase");
- NonViralName<?> taxonnamebase2 = nvn;
- if (nomenclaturalCode.equals(NomenclaturalCode.ICNAFP)) {
- try{
- taxonnamebase2=(BotanicalName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- if (nomenclaturalCode.equals(NomenclaturalCode.ICZN)) {
- try{
- taxonnamebase2=(ZoologicalName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- if (nomenclaturalCode.equals(NomenclaturalCode.ICNB)) {
- try{
- taxonnamebase2=(BacterialName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- return taxonnamebase2;
- }
- /**
- * @param tnb
- * cast the current taxonnamebase into a botanical name or zoological or bacterial name
- * if errors, cast into a classis nonviralname
- * @param taxonnamebase2
- */
- @SuppressWarnings("rawtypes")
- public NonViralName<?> castTaxonNameBase(TaxonNameBase tnb) {
- //logger.info("castTaxonNameBase2");
- NonViralName<?> taxonnamebase2 = null;
- tnb=CdmBase.deproxy(tnb, TaxonNameBase.class);
- if (nomenclaturalCode.equals(NomenclaturalCode.ICNAFP)) {
- try{
- taxonnamebase2=(BotanicalName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- if (nomenclaturalCode.equals(NomenclaturalCode.ICZN)) {
- try{
- taxonnamebase2=(ZoologicalName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- if (nomenclaturalCode.equals(NomenclaturalCode.ICNB)) {
- try{
- taxonnamebase2=(BacterialName) tnb;
- }catch(Exception e){
- taxonnamebase2= (NonViralName<?>) tnb;
- }
- }
- return taxonnamebase2;
- }
public class MyName {
/**
String status="";
String author=null;
- NonViralName<?> taxonNameBase;
+ TaxonNameBase<?,?> taxonNameBase;
Reference refMods ;
Taxon family,subfamily,tribe,subtribe,genus,subgenus,species,subspecies, variety,form;
- NonViralName<?> familyName, subfamilyName, tribeName,subtribeName,genusName,subgenusName,speciesName,subspeciesName;
+ INonViralName familyName, subfamilyName, tribeName,subtribeName,genusName,subgenusName,speciesName,subspeciesName;
String familyStr, subfamilyStr, tribeStr,subtribeStr,genusStr,subgenusStr,speciesStr,subspeciesStr,formStr,varietyStr;
Integer publicationYear;
this.syno=(Synonym)tmpTaxonBase;
}
- taxonNameBase = castTaxonNameBase(tnb, taxonNameBase);
+ taxonNameBase = tnb;
}
author1=taxonNameBase.getAuthorshipCache();
}
try {
- if(castTaxonNameBase(bestMatchingTaxon.getName()).getAuthorshipCache()!=null) {
- author2=castTaxonNameBase(bestMatchingTaxon.getName()).getAuthorshipCache();
+ if(bestMatchingTaxon.getName().getAuthorshipCache()!=null) {
+ author2=bestMatchingTaxon.getName().getAuthorshipCache();
}
} catch (Exception e) {
// TODO Auto-generated catch block
/**
* @param nameToBeFilledTest
*/
- @SuppressWarnings("rawtypes")
public void setParsedName(ITaxonNameBase nameToBeFilledTest) {
- this.taxonNameBase = (NonViralName<?>) nameToBeFilledTest;
+ this.taxonNameBase = TaxonNameBase.castAndDeproxy(nameToBeFilledTest);
}
//variety dwcranks:varietyEpithet
/**
* @return
*/
- public NonViralName<?> getTaxonNameBase() {
+ public TaxonNameBase<?,?> getTaxonNameBase() {
return taxonNameBase;
}
}
if ((tmp == null || !foundIdentic) || (tmp != null && !statusMatch) || (tmp != null && !appendedMatch && !statusMatch)){
- NonViralName<?> tnb = getNonViralNameAccNomenclature();
+ INonViralName tnb = getNonViralNameAccNomenclature();
tnb.setRank(rank);
if(statusType != null) {
* @param tnb
* @return
*/
- private Taxon buildSubfamily(NonViralName<?> tnb) {
+ private Taxon buildSubfamily(INonViralName tnb) {
Taxon tmp;
// tnb.generateTitle();
tmp = findMatchingTaxon(tnb,refMods);
* @param tnb
* @return
*/
- private Taxon buildFamily(NonViralName<?> tnb) {
+ private Taxon buildFamily(INonViralName tnb) {
Taxon tmp;
// tnb.generateTitle();
tmp = findMatchingTaxon(tnb,refMods);
* @param tnb
* @return
*/
- private Taxon buildForm(String fullname, String partialname, NonViralName<?> tnb) {
+ private Taxon buildForm(String fullname, String partialname, INonViralName tnb) {
if (genusName !=null) {
tnb.setGenusOrUninomial(genusName.getGenusOrUninomial());
}
* @param tnb
* @return
*/
- private Taxon buildVariety(String fullname, String partialname, NonViralName<?> tnb) {
+ private Taxon buildVariety(String fullname, String partialname, INonViralName tnb) {
Taxon tmp;
if (genusName !=null) {
tnb.setGenusOrUninomial(genusName.getGenusOrUninomial());
* @param tnb
* @return
*/
- private Taxon buildSubspecies(String partialname, NonViralName<?> tnb) {
+ private Taxon buildSubspecies(String partialname, INonViralName tnb) {
if (genusName !=null) {
tnb.setGenusOrUninomial(genusName.getGenusOrUninomial());
}
* @param tnb
* @return
*/
- private Taxon buildSpecies(String partialname, NonViralName<?> tnb) {
+ private Taxon buildSpecies(String partialname, INonViralName tnb) {
if (genusName !=null) {
tnb.setGenusOrUninomial(genusName.getGenusOrUninomial());
}
* @param tnb
* @return
*/
- private Taxon buildSubgenus(String partialname, NonViralName<?> tnb) {
+ private Taxon buildSubgenus(String partialname, INonViralName tnb) {
tnb.setInfraGenericEpithet(partialname);
if (genusName !=null) {
tnb.setGenusOrUninomial(genusName.getGenusOrUninomial());
* @param tnb
* @return
*/
- private Taxon buildGenus(String partialname, NonViralName<?> tnb) {
+ private Taxon buildGenus(String partialname, INonViralName tnb) {
Taxon tmp;
tnb.setGenusOrUninomial(partialname);
* @param tnb
* @return
*/
- private Taxon buildSubtribe(NonViralName<?> tnb) {
+ private Taxon buildSubtribe(INonViralName tnb) {
Taxon tmp = findMatchingTaxon(tnb,refMods);
if(tmp==null){
tmp = Taxon.NewInstance(tnb, sourceUrlRef);
* @param tnb
* @return
*/
- private Taxon buildTribe(NonViralName<?> tnb) {
+ private Taxon buildTribe(INonViralName tnb) {
Taxon tmp = findMatchingTaxon(tnb,refMods);
if(tmp==null){
tmp = Taxon.NewInstance(tnb, sourceUrlRef);
@SuppressWarnings("rawtypes")
public void setFamily(Taxon family) {
this.family = family;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(family.getName(), TaxonNameBase.class);
- familyName = castTaxonNameBase(taxonNameBase,familyName);
+ familyName = CdmBase.deproxy(family.getName());
}
/**
* @return the subfamily
@SuppressWarnings("rawtypes")
public void setSubfamily(Taxon subfamily) {
this.subfamily = subfamily;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(subfamily.getName(), TaxonNameBase.class);
- subfamilyName = castTaxonNameBase(taxonNameBase,subfamilyName);
+ subfamilyName = CdmBase.deproxy(subfamily.getName());
}
/**
* @return the tribe
@SuppressWarnings("rawtypes")
public void setTribe(Taxon tribe) {
this.tribe = tribe;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(tribe.getName(), TaxonNameBase.class);
- tribeName = castTaxonNameBase(taxonNameBase,tribeName);
+ tribeName = CdmBase.deproxy(tribe.getName());
}
/**
* @return the subtribe
@SuppressWarnings("rawtypes")
public void setSubtribe(Taxon subtribe) {
this.subtribe = subtribe;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(subtribe.getName(), TaxonNameBase.class);
- subtribeName =castTaxonNameBase(taxonNameBase,subtribeName);
+ subtribeName =CdmBase.deproxy(subtribe.getName());
}
/**
* @return the genus
public void setGenus(Taxon genus) {
if (genus != null){
this.genus = genus;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(genus.getName(), TaxonNameBase.class);
- genusName = castTaxonNameBase(taxonNameBase,genusName);
+ genusName = CdmBase.deproxy(genus.getName());
}
}
/**
@SuppressWarnings("rawtypes")
public void setSubgenus(Taxon subgenus) {
this.subgenus = subgenus;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(subgenus.getName(), TaxonNameBase.class);
- subgenusName = castTaxonNameBase(taxonNameBase,subgenusName);
+ subgenusName = CdmBase.deproxy(subgenus.getName());
}
/**
* @return the species
public void setSpecies(Taxon species) {
if (species != null){
this.species = species;
- @SuppressWarnings("rawtypes")
- TaxonNameBase taxonNameBase = CdmBase.deproxy(species.getName(), TaxonNameBase.class);
- speciesName = castTaxonNameBase(taxonNameBase,speciesName);
+ speciesName = CdmBase.deproxy(species.getName());
}
}
/**
@SuppressWarnings("rawtypes")
public void setSubspecies(Taxon subspecies) {
this.subspecies = subspecies;
- TaxonNameBase taxonNameBase = CdmBase.deproxy(subspecies.getName(), TaxonNameBase.class);
- subspeciesName = castTaxonNameBase(taxonNameBase,subspeciesName);
+ subspeciesName = CdmBase.deproxy(subspecies.getName());
}
e.printStackTrace();
}
try {
- if(castTaxonNameBase(bestMatchingTaxon.getName()).getAuthorshipCache()!=null) {
- author2=castTaxonNameBase(bestMatchingTaxon.getName()).getAuthorshipCache();
+ if(bestMatchingTaxon.getName().getAuthorshipCache()!=null) {
+ author2=bestMatchingTaxon.getName().getAuthorshipCache();
}
} catch (Exception e) {
// TODO Auto-generated catch block
* @param taxonNameBase
*/
@SuppressWarnings("rawtypes")
- public void lookForParentNode(NonViralName<?> taxonNameBase, Taxon tax, Reference ref, MyName myName) {
+ public void lookForParentNode(INonViralName taxonNameBase, Taxon tax, Reference ref, MyName myName) {
logger.info("lookForParentNode "+taxonNameBase.getTitleCache()+" for "+myName.toString());
//System.out.println("LOOK FOR PARENT NODE "+taxonnamebase.toString()+"; "+tax.toString()+"; "+taxonnamebase.getRank());
INonViralNameParser parser = NonViralNameParserImpl.NewInstance();
}
}
if(parent == null) {
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon tmp = findMatchingTaxon(parentNameName,ref);
if(tmp ==null)
{
r = Rank.FAMILY();
}
if(parentStr!=null){
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null
// importer.getTaxonService().save(parent);
// parent = CdmBase.deproxy(parent, Taxon.class);
r = Rank.FAMILY();
}
if(parentStr!=null){
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null
// importer.getTaxonService().save(parent);
// parent = CdmBase.deproxy(parent, Taxon.class);
r = Rank.FAMILY();
}
if(parentStr!=null){
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null
// importer.getTaxonService().save(parent);
// parent = CdmBase.deproxy(parent, Taxon.class);
r = Rank.FAMILY();
}
if(parentStr!=null){
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null
// importer.getTaxonService().save(parent);
// parent = CdmBase.deproxy(parent, Taxon.class);
* @return
*/
private Taxon handleParentName(Reference ref, MyName myName, INonViralNameParser<?> parser, String parentStr, Rank r) {
- NonViralName<?> parentNameName = (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);
+ INonViralName parentNameName = parser.parseFullName(parentStr, nomenclaturalCode, r);
Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null
// importer.getTaxonService().save(parent);
// parent = CdmBase.deproxy(parent, Taxon.class);
import eu.etaxonomy.cdm.model.common.Marker;
import eu.etaxonomy.cdm.model.common.MarkerType;
import eu.etaxonomy.cdm.model.common.TimePeriod;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
}
if (nameBase instanceof NonViralName){
- NonViralName<?> nonViralName = (NonViralName<?>)nameBase;
+ INonViralName nonViralName = nameBase;
prop = nameAbout.getModel().getProperty(config.getTnNamespaceURIString()+"genusPart");
String strGenusPart;
try{
}
if (nameBase instanceof NonViralName){
- NonViralName<?> nonViralName = (NonViralName<?>)nameBase;
+ INonViralName nonViralName = nameBase;
String strGenusPart = XmlHelp.getChildContent(elTaxonName, "TaxonName", taxonNameNamespace, "genusPart", rdfNamespace);
//for names of rank genus the uninomial property should be used
}
if (nameBase instanceof NonViralName){
- NonViralName<?> nonViralName = (NonViralName<?>)nameBase;
+ INonViralName nonViralName = nameBase;
String strGenusPart = XmlHelp.getChildContent(elTaxonName, "TaxonName", taxonNameNamespace, "genusPart", rdfNamespace);
//for names of rank genus the uninomial property should be used
String simple = (elSimple == null)? "" : elSimple.getTextNormalize();
name.setFullTitleCache(simple, cacheProtected);
- if (name instanceof NonViralName<?>){
- NonViralName<?> nonViralName = (NonViralName<?>)name;
+ if (name instanceof NonViralName){
+ INonViralName nonViralName = name;
childName = "Uninomial";
obligatory = false;
Element elUninomial = XmlHelp.getSingleChildElement(success, elCanonicalName, childName, ns, obligatory);
import eu.etaxonomy.cdm.database.ICdmDataSource;
import eu.etaxonomy.cdm.io.dwca.in.IImportMapping.CdmKey;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
/**
ICdmDataSource datasource = mapping.getDatabase();
Assert.assertNotNull("Datasource should not be null", datasource);
- BotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonNameBase<?,?> botName1 = TaxonNameFactory.NewBotanicalInstance(null);
int id = 23;
botName1.setId(id);
String sourceNS = "sourceNS";
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.description.TextData;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.Classification;\r
Set<Synonym> synonyms = noctuaPronubaTaxon.getSynonyms();\r
assertEquals("Number of synonyms should be 1", 1, synonyms.size());\r
Synonym synonym = synonyms.iterator().next();\r
- assertEquals("Synonym name should be ", "Noctua atlantica", ((NonViralName<?>)synonym.getName()).getNameCache());\r
+ assertEquals("Synonym name should be ", "Noctua atlantica", synonym.getName().getNameCache());\r
Set<TaxonDescription> descriptions = noctuaPronubaTaxon.getDescriptions();\r
Assert.assertEquals("Number of descriptions should be 1", 1, descriptions.size());\r
TaxonDescription taxonDescription = descriptions.iterator().next();\r
Set<Synonym> synonyms = noctuaPronubaTaxon.getSynonyms();\r
assertEquals("Number of synonyms should be 1", 1, synonyms.size());\r
Synonym synonym = synonyms.iterator().next();\r
- assertEquals("Synonym name should be ", "Noctua atlantica", ((NonViralName<?>)synonym.getName()).getNameCache());\r
+ assertEquals("Synonym name should be ", "Noctua atlantica", synonym.getName().getNameCache());\r
Set<TaxonDescription> descriptions = noctuaPronubaTaxon.getDescriptions();\r
Assert.assertEquals("Number of descriptions should be 1", 1, descriptions.size());\r
TaxonDescription taxonDescription = descriptions.iterator().next();\r
/**\r
* Copyright (C) 2009 EDIT\r
-* European Distributed Institute of Taxonomy \r
+* European Distributed Institute of Taxonomy\r
* http://www.e-taxonomy.eu\r
-* \r
+*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
*/\r
\r
import org.junit.Test;\r
\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
+import eu.etaxonomy.cdm.model.name.IBotanicalName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;\r
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;\r
-import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;\r
\r
public class TaxonNameTest {\r
- \r
+\r
private String resource = "/eu/etaxonomy/cdm/io/jaxb/TaxonNameTest.xml";\r
- \r
+\r
@Test\r
public void testUnmarshalName() throws Exception {\r
CdmDocumentBuilder cdmDocumentBuilder = new CdmDocumentBuilder();\r
URI uri = new URI(URIEncoder.encode(this.getClass().getResource(resource).toString()));\r
DataSet dataSet = cdmDocumentBuilder.unmarshal(DataSet.class, new InputStreamReader(this.getClass().getResourceAsStream(resource)),uri.toString());\r
- \r
- BotanicalName botanicalName = (BotanicalName)dataSet.getTaxonomicNames().get(0); \r
+\r
+ IBotanicalName botanicalName = dataSet.getTaxonomicNames().get(0);\r
assertNotNull("BotanicalName must not be null",botanicalName);\r
DerivedUnit specimen = (DerivedUnit)dataSet.getOccurrences().get(0);\r
- \r
+\r
assertNotNull("BotanicalName.typeDesignations must not be null",botanicalName.getTypeDesignations());\r
assertFalse("BotanicalName.typeDesignations must contain TypeDesignation entities", botanicalName.getTypeDesignations().isEmpty());\r
- \r
+\r
SpecimenTypeDesignation specimenTypeDesignation = (SpecimenTypeDesignation)botanicalName.getTypeDesignations().iterator().next();\r
assertNotNull("SpecimenTypeDesignation.typifiedNames must not be null",specimenTypeDesignation.getTypifiedNames());\r
assertFalse("SpecimenTypeDesignation.typifiedNames must not be empty",specimenTypeDesignation.getTypifiedNames().isEmpty());\r
assertTrue("SpecimenTypeDesignation.typifiedNames must contain BotanicalName",specimenTypeDesignation.getTypifiedNames().contains(botanicalName));\r
- \r
+\r
assertNotNull("SpecimenTypeDesignation.typeSpecimen must not be null",specimenTypeDesignation.getTypeSpecimen());\r
assertEquals("SpecimenTypeDesignation.typeSpecimen must equal Specimen",specimen,specimenTypeDesignation.getTypeSpecimen());\r
- \r
- ZoologicalName zoologicalName = (ZoologicalName)dataSet.getTaxonomicNames().get(5); \r
+\r
+ IZoologicalName zoologicalName = dataSet.getTaxonomicNames().get(5);\r
assertNotNull("ZoologicalName must not be null",zoologicalName);\r
- \r
+\r
NameTypeDesignation nameTypeDesignation = (NameTypeDesignation)zoologicalName.getTypeDesignations().iterator().next();\r
assertNotNull("NameTypeDesignation.typeName must not be null",nameTypeDesignation.getTypeName());\r
assertEquals("NameTypeDesignation.typeName must equal ZoologicalName",dataSet.getTaxonomicNames().get(6),nameTypeDesignation.getTypeName());\r
- \r
+\r
}\r
}\r
import eu.etaxonomy.cdm.model.agent.Institution;
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.molecular.DnaSample;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
assertEquals(2, derivedUnit.getDeterminations().size());
for(DeterminationEvent determinationEvent:derivedUnit.getDeterminations()){
if(determinationEvent.getPreferredFlag()){
- assertEquals(preferredNameCache,((NonViralName<?>) determinationEvent.getTaxonName()).getNameCache());
+ assertEquals(preferredNameCache,determinationEvent.getTaxonName().getNameCache());
}
else{
- assertEquals(nonPreferredNameCache,((NonViralName<?>) determinationEvent.getTaxonName()).getNameCache());
+ assertEquals(nonPreferredNameCache,determinationEvent.getTaxonName().getNameCache());
}
}
// Team team = Team.NewTitledInstance("different author", "different author");
// secReference.setAuthorship(team);
//
-// NonViralName<?> taxonName = TaxonNameFactory.NewNonViralInstance(Rank.VARIETY());
+// INonViralName taxonName = TaxonNameFactory.NewNonViralInstance(Rank.VARIETY());
// taxonName.setGenusOrUninomial("Campanula");
// taxonName.setSpecificEpithet("versicolor");
// taxonName.setInfraSpecificEpithet("tomentella");
import org.hibernate.search.annotations.SortableField;
import org.hibernate.search.annotations.Store;
import org.hibernate.validator.constraints.NotEmpty;
+
import eu.etaxonomy.cdm.hibernate.search.StripHtmlBridge;
import eu.etaxonomy.cdm.jaxb.FormattedTextAdapter;
}
-
-
/**
* Returns the {@link eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy cache strategy} used to generate
* several strings corresponding to <i>this</i> identifiable entity
* Returns the {@link NomenclaturalCode nomenclatural code} that governs
* the construction of <i>this</i> bacterial taxon name, that is the
* International Code of Nomenclature of Bacteria. This method overrides
- * the getNomenclaturalCode method from {@link NonViralName NonViralName}.
+ * the getNomenclaturalCode method from {@link INonViralName NonViralName}.
*
* @return the nomenclatural code for bacteria
* @see NonViralName#isCodeCompliant()
* Returns the {@link NomenclaturalCode nomenclatural code} that governs
* the construction of <i>this</i> botanical taxon name, that is the
* International Code of Botanical Nomenclature. This method overrides
- * the getNomenclaturalCode method from {@link NonViralName NonViralName}.
+ * the getNomenclaturalCode method from {@link INonViralName NonViralName}.
*
* @return the nomenclatural code for plants
* @see NonViralName#isCodeCompliant()
*/
@Override
public Object clone() {
- BotanicalName result = (BotanicalName)super.clone();
+ IBotanicalName result = (IBotanicalName)super.clone();
//no changes to:
return result;
}
*/
@Override
public Object clone() {
- BotanicalName result = (BotanicalName)super.clone();
+ CultivarPlantName result = (CultivarPlantName)super.clone();
//no changes to:
return result;
}
// * Open: All types of relationships to replaced synonyms
// */
// public void guessAndSetBasionym(){
-// Map<String, NonViralName<?>> candidates = new HashMap<NonViralName<?>>();
+// Map<String, INonViralName> candidates = new HashMap<>();
// for (TaxonNameBase<?,?> typifiedName : this.typifiedNames){
// if (! typifiedName.protectedAuthorshipCache && nvn.getBasionymAuthorship() == null){
// candidates.add(typifiedName);
})
@Entity
@Audited
-public class HybridRelationship extends RelationshipBase<TaxonNameBase, TaxonNameBase, HybridRelationshipType> implements Cloneable, Comparable<HybridRelationship>{
+public class HybridRelationship extends RelationshipBase<INonViralName, INonViralName, HybridRelationshipType> implements Cloneable, Comparable<HybridRelationship>{
private static final Logger logger = Logger.getLogger(HybridRelationship.class);
//The nomenclatural code rule considered. The article/note/recommendation in the code in question that is commented on in
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch=FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonNameBase relatedFrom;
+ private TaxonNameBase<?,?> relatedFrom;
@XmlElement(name = "RelatedTo")
@XmlIDREF
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch=FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private TaxonNameBase relatedTo;
+ private TaxonNameBase<?,?> relatedTo;
@XmlElement(name = "Type")
@XmlIDREF
* @param type the relationship type to be assigned to the new hybrid relationship
* @param ruleConsidered the string indicating the article of the ICBN for the hybrid taxon name
* @see #HybridRelationship(BotanicalName, BotanicalName, HybridRelationshipType, Reference, String, String)
- * @see BotanicalName#addHybridRelationship(HybridRelationship)
+ * @see TaxonNameBase#addHybridRelationship(HybridRelationship)
*/
- protected HybridRelationship(TaxonNameBase hybridName, TaxonNameBase parentName, HybridRelationshipType type, String ruleConsidered) {
+ protected HybridRelationship(INonViralName hybridName, INonViralName parentName, HybridRelationshipType type, String ruleConsidered) {
this(hybridName, parentName, type, null, null, ruleConsidered);
}
* @param citationMicroReference the string with the details describing the exact localisation within the reference
* @param ruleConsidered the string indicating the article of the ICBN for the hybrid taxon name
* @see #HybridRelationship(BotanicalName, BotanicalName, HybridRelationshipType, String)
- * @see BotanicalName#addHybridRelationship(HybridRelationship)
+ * @see TaxonNameBase#addHybridRelationship(HybridRelationship)
*/
- protected HybridRelationship(TaxonNameBase hybridName, TaxonNameBase parentName, HybridRelationshipType type, Reference citation, String citationMicroReference, String ruleConsidered) {
+ protected HybridRelationship(INonViralName hybridName, INonViralName parentName, HybridRelationshipType type, Reference citation, String citationMicroReference, String ruleConsidered) {
super(parentName, hybridName, type, citation, citationMicroReference);
this.setRuleConsidered(ruleConsidered);
}
}
@Override
- protected void setRelatedFrom(TaxonNameBase relatedFrom) {
- this.relatedFrom = relatedFrom;
+ protected void setRelatedFrom(INonViralName relatedFrom) {
+ this.relatedFrom = TaxonNameBase.castAndDeproxy(relatedFrom);
}
@Override
- protected void setRelatedTo(TaxonNameBase relatedTo) {
- this.relatedTo = relatedTo;
+ protected void setRelatedTo(INonViralName relatedTo) {
+ this.relatedTo = TaxonNameBase.castAndDeproxy(relatedTo);
}
@Override
/**
* Returns the "first parent" hybrid relationship type. The elements of the
- * {@link NonViralName non-viral taxon name} used as "first parent" affect the
+ * {@link INonViralName non-viral taxon name} used as "first parent" affect the
* taxon name string of the hybrid (see Appendix I of the ICBN).
*
* @see #SECOND_PARENT()
/**
* Returns the "second parent" hybrid relationship type. The elements of the
- * {@link NonViralName non-viral taxon name} used as "second parent" affect the
+ * {@link INonViralName non-viral taxon name} used as "second parent" affect the
* taxon name string of the hybrid (see Appendix I of the ICBN).
*
* @see #FIRST_PARENT()
/**
* Returns the "third parent" hybrid relationship type. The elements of the
- * {@link NonViralName non viral taxon name} used as "third parent" affect the
+ * {@link INonViralName non viral taxon name} used as "third parent" affect the
* taxon name string of the hybrid (see Appendix I of the ICBN).
*
* @see #FIRST_PARENT()
/**
* Returns the "fourth parent" hybrid relationship type. The elements of the
- * {@link NonViralName non viral taxon name} used as "third parent" affect the
+ * {@link INonViralName non viral taxon name} used as "third parent" affect the
* taxon name string of the hybrid (see Appendix I of the ICBN).
*
* @see #FIRST_PARENT()
/**
* Returns the "female parent" hybrid relationship type. The taxon the name
* of which plays the female parent role is the genetic mother of the taxon
- * which is the hybrid (and has the hybrid {@link NonViralName non-viral taxon name})<BR>
+ * which is the hybrid (and has the hybrid {@link INonViralName non-viral taxon name})<BR>
* For nomenclature purposes a "female parent" is also a "first parent".
*
* @see #MALE_PARENT()
/**
* Returns the "male parent" hybrid relationship type. The taxon the name
* of which plays the male parent role is the genetic father of the taxon
- * which is the hybrid (and has the hybrid {@link NonViralName non-viral taxon name}).<BR>
+ * which is the hybrid (and has the hybrid {@link INonViralName non-viral taxon name}).<BR>
* For nomenclature purposes a "male parent" is also a "second parent".
*
* @see #MALE_PARENT()
*/
public interface IBotanicalName extends INonViralName {
- /**
- * Returns the boolean value of the flag indicating whether the specimen
- * type of <i>this</i> botanical taxon name for a fungus is asexual (true) or not
- * (false). This applies only in case of fungi. The Article 59 of the ICBN
- * permits mycologists to give asexually reproducing fungi (anamorphs)
- * separate names from their sexual states (teleomorphs).
- *
- * @return the boolean value of the isAnamorphic flag
- */
- public boolean isAnamorphic();
-
- /**
- * @see #isAnamorphic()
- */
- public void setAnamorphic(boolean anamorphic);
+// /**
+// * Returns the boolean value of the flag indicating whether the specimen
+// * type of <i>this</i> botanical taxon name for a fungus is asexual (true) or not
+// * (false). This applies only in case of fungi. The Article 59 of the ICBN
+// * permits mycologists to give asexually reproducing fungi (anamorphs)
+// * separate names from their sexual states (teleomorphs).
+// *
+// * @return the boolean value of the isAnamorphic flag
+// */
+// public boolean isAnamorphic();
+//
+// /**
+// * @see #isAnamorphic()
+// */
+// public void setAnamorphic(boolean anamorphic);
}
* @see #addRelationshipFromName(TaxonNameBase, NameRelationshipType, String)
* @see #addNameRelationship(NameRelationship)
*/
- public HybridRelationship addHybridChild(NonViralName childName, HybridRelationshipType type, String ruleConsidered);
+ public HybridRelationship addHybridChild(INonViralName childName, HybridRelationshipType type, String ruleConsidered);
/**
* Creates a new {@link HybridRelationship#HybridRelationship(TaxonNameBase, TaxonNameBase, HybridRelationshipType, String) hybrid relationship}
* @see #addRelationshipFromName(TaxonNameBase, NameRelationshipType, String)
* @see #addNameRelationship(NameRelationship)
*/
- public HybridRelationship addHybridParent(NonViralName parentName, HybridRelationshipType type, String ruleConsidered);
+ public HybridRelationship addHybridParent(INonViralName parentName, HybridRelationshipType type, String ruleConsidered);
/**
* Shortcut. Returns the basionym authors title cache. Returns null if no basionym author exists.
*/
public boolean isProtectedNameCache();
- public void removeHybridChild(NonViralName child);
+ public void removeHybridChild(INonViralName child);
- public void removeHybridParent(NonViralName parent);
+ public void removeHybridParent(INonViralName parent);
/**
* Removes one {@link HybridRelationship hybrid relationship} from the set of
public interface ITaxonNameBase
extends IIdentifiableEntity, IParsable, IRelated, IMatchable, Cloneable{
+ public int compareTo(IdentifiableEntity identifiableEntity);
+
+ public Object clone();
+
public String generateFullTitle();
@Transient
* @see #getPublicationYear()
*/
public void setPublicationYear(Integer publicationYear);
+
}
* {@link Rank ranks}) must be (almost) identical, so one could be mistaken for
* the other one. The first taxon name is "illegitimate" and the second one
* is "legitimate" (this corresponds to "invalid" and "valid" in case of
- * {@link ZoologicalName zoological names}).<BR>
+ * {@link IZoologicalName zoological names}).<BR>
* For instance <i>Astragalus rhizanthus</i> Boiss. is a later homonym of
* <i>Astragalus rhizanthus</i> Royle.<BR>
* This type is not symmetric but transitive.
* {@link Rank#isInfraSpecific() infraspecific ranks} and {@link NonViralName#getAuthorshipCache() authorship}) must be
* almost identical (so one could be mistaken for the other). The first
* taxon name is "illegitimate" and the second one is "legitimate" (this
- * corresponds to "invalid" and "valid" in case of {@link ZoologicalName zoological names}).<BR>
+ * corresponds to "invalid" and "valid" in case of {@link IZoologicalName zoological names}).<BR>
* This type is not symmetric but transitive.
*
* @see #LATER_HOMONYM()
* Competent authorities decided, regardless of the general
* nomenclatural rules, to handle the first one as the "legitimate"
* one and the second taxon name as "illegitimate" (this corresponds to
- * "valid" and "invalid" in case of {@link ZoologicalName zoological names}).<BR>
+ * "valid" and "invalid" in case of {@link IZoologicalName zoological names}).<BR>
* For instance <i>Cephaloziella</i> (Spruce) Schiffn. is conserved against
* <i>Dichiton</i> Mont.<BR>
* This type is neither symmetric nor transitive.
/**
* Returns the boolean value indicating whether <i>this</i> nomenclatural status
* type is itself "invalid" or a kind of "invalid" (true) or not (false) -
- * this corresponds to "not available" for {@link ZoologicalName zoological names} -.
+ * this corresponds to "not available" for {@link IZoologicalName zoological names} -.
* Returns false if <i>this</i> nomenclatural status type is null. The use
* of "invalid" {@link TaxonNameBase taxon names} should be avoided.<BR>
* A taxon name is "invalid" if it is not "valid"; this means that
/**
* Returns the boolean value indicating whether <i>this</i> nomenclatural status
* type is itself "legitimate" or a kind of "legitimate" (true)
- * or not (false). Corresponds to "valid" for {@link ZoologicalName zoological names}.<BR>
+ * or not (false). Corresponds to "valid" for {@link IZoologicalName zoological names}.<BR>
* Returns false if <i>this</i> nomenclatural status type is null.<BR>
* A "valid" (zool.: "available") {@link TaxonNameBase taxon name}, unless "rejected",
* is "legitimate" if it was not "superfluous" when published
/**
* Returns the boolean value indicating whether <i>this</i> nomenclatural status
* type is itself "illegitimate" or a kind of "illegitimate" (true)
- * or not (false) - this corresponds to "invalid" for {@link ZoologicalName zoological names} -.
+ * or not (false) - this corresponds to "invalid" for {@link IZoologicalName zoological names} -.
* Returns false if <i>this</i> nomenclatural status type is null.<BR>
* A "valid" ("available") {@link TaxonNameBase taxon name}, unless "conserved" or
* "sanctioned", is "illegitimate" if it was "superfluous" when published
* by different authors in different senses (other than the originally
* intended) that it has become a persistent cause of error and confusion.<BR>
* An "ambiguous" taxon name is treated as if "rejected" and is therefore
- * also "illegitimate" ("invalid" for {@link ZoologicalName zoological names}).
+ * also "illegitimate" ("invalid" for {@link IZoologicalName zoological names}).
*
* @see #VALID()
* @see #REJECTED()
* application is uncertain; the confusion being derived from an incomplete
* or confusing description.<BR>
* A "doubtful" taxon name is treated as if "rejected" and is therefore
- * also "illegitimate" (("invalid" for {@link ZoologicalName zoological names}).
+ * also "illegitimate" (("invalid" for {@link IZoologicalName zoological names}).
*
* @see #VALID()
* @see #REJECTED()
* {@link TaxonNameBase taxon name} is "confusum" if it has been widely
* and persistently used for a taxon or taxa not including its type.<BR>
* A "confusum" taxon name is treated as if "rejected" and is therefore
- * also "illegitimate" ("invalid" for {@link ZoologicalName zoological names}).
+ * also "illegitimate" ("invalid" for {@link IZoologicalName zoological names}).
*
* @see #VALID()
* @see #REJECTED()
/**
* Returns the nomenclatural status type "illegitimate" ("invalid" for
- * {@link ZoologicalName zoological names}). A "valid" ("available")
+ * {@link IZoologicalName zoological names}). A "valid" ("available")
* {@link TaxonNameBase taxon name}, unless "conserved" or "sanctioned", is "illegitimate"
* if it was "superfluous" when published or has been later "rejected".<BR>
*
* the {@link NomenclaturalCode nomenclature code}, and if it has not been later declared
* "conserved" or "sanctioned" by the competent authorities.<BR>
* A "superfluous" taxon name is therefore also "illegitimate" ("invalid" for
- * {@link ZoologicalName zoological names}).
+ * {@link IZoologicalName zoological names}).
*
* @see #VALID()
* @see #CONSERVED()
* {@link TaxonNameBase taxon name} is "rejected" if, even though by the strict
* application of the rules of the {@link NomenclaturalCode nomenclature code}, and especially
* of the principle of priority, it should be "legitimate" ("valid" for
- * {@link ZoologicalName zoological names}), competent authorities decided to handle
+ * {@link IZoologicalName zoological names}), competent authorities decided to handle
* it as "illegitimate".<BR>
* A "rejected" taxon name is therefore also "illegitimate" ("invalid" for
* zoological names). A "rejected" taxon name is always rejected in favour
* "valid" ("available") {@link TaxonNameBase taxon name} is "proposed to be conserved"
* if, even though by the strict application of the rules of
* the {@link NomenclaturalCode nomenclature code}, and especially of the principle of priority,
- * it is "illegitimate" ("invalid" for {@link ZoologicalName zoological names}),
+ * it is "illegitimate" ("invalid" for {@link IZoologicalName zoological names}),
* it has been submitted to competent authorities in order to decide whether
* it should be handled as "legitimate".<BR>
* A "proposed to be conserved" taxon name is therefore still "illegitimate"
* spelling, it has been submitted to competent authorities in order to
* decide whether the proposed alternative spelling should be "conserved".<BR>
* A "proposed to be conserved (orthography)" taxon name is therefore still
- * "illegitimate" ("invalid" for {@link ZoologicalName zoological names}).
+ * "illegitimate" ("invalid" for {@link IZoologicalName zoological names}).
*
* @see #isIllegitimateType()
* @see #CONSERVED_PROP()
/**
* Returns the nomenclatural status type "legitimate" ("valid" for
- * {@link ZoologicalName zoological names}). A "valid" ("available")
+ * {@link IZoologicalName zoological names}). A "valid" ("available")
* {@link TaxonNameBase taxon name}, unless "rejected", is "legitimate" if it was not
* "superfluous" when published or has been later "conserved".<BR>
*
* in order either to replace an earlier name that is "illegitimate" or to
* avoid the building of a "later homonym".<BR>
* A "novum" taxon name is therefore also "legitimate" ("valid" for
- * {@link ZoologicalName zoological names}).
+ * {@link IZoologicalName zoological names}).
*
* @see #VALID()
* @see #isIllegitimateType()
* "valid" ("available") {@link TaxonNameBase taxon name} is "proposed to be utique rejected"
* if, even though by the strict application of the rules of
* the {@link NomenclaturalCode nomenclature code}, and especially of the principle of priority,
- * it is "legitimate" ("valid" for {@link ZoologicalName zoological names}),
+ * it is "legitimate" ("valid" for {@link IZoologicalName zoological names}),
* it has been submitted to competent authorities in order to decide whether
* it should be handled as "illegitimate" (without to be rejected in favour
* of a "conserved" taxon name).<BR>
* {@link TaxonNameBase taxon name} is "conserved (orthography)" if competent authorities
* decided to conserve a different spelling to the one published originally.<BR>
* A "conserved (orthography)" taxon name is "conserved" and hence
- * "legitimate" ("valid" for {@link ZoologicalName zoological names}).
+ * "legitimate" ("valid" for {@link IZoologicalName zoological names}).
*
* @see #isLegitimateType()
* @see #CONSERVED()
* "valid" ("available") {@link TaxonNameBase taxon name} is "proposed to be rejected"
* if, even though by the strict application of the rules of
* the {@link NomenclaturalCode nomenclature code}, and especially of the principle of priority,
- * it should be "legitimate" ("valid" for {@link ZoologicalName zoological names}),
+ * it should be "legitimate" ("valid" for {@link IZoologicalName zoological names}),
* it has been submitted to competent authorities in order to decide whether
* it should be handled as "illegitimate".<BR>
* A "proposed to be rejected" taxon name is therefore still "legitimate"
* ("available") {@link TaxonNameBase taxon name} is "conserved" if, even though by the strict
* application of the rules of the {@link NomenclaturalCode nomenclature code}, and especially of
* the principle of priority, it should be "illegitimate" ("invalid" for
- * {@link ZoologicalName zoological names}), competent authorities decided to handle
+ * {@link IZoologicalName zoological names}), competent authorities decided to handle
* it as "legitimate".<BR>
* A "conserved" taxon name is therefore also "legitimate" ("valid" for
* zoological names).
/**
* Returns the nomenclatural status type "invalid" (this corresponds to
- * "not available" for {@link ZoologicalName zoological names}). The use of "invalid"
+ * "not available" for {@link IZoologicalName zoological names}). The use of "invalid"
* {@link TaxonNameBase taxon names} should be avoided.<BR>
* A taxon name is "invalid" if it is not "valid"; this means that
* the taxon name:<ul>
* if its publication is not accompanied by a description or diagnosis or
* by a reference to such a previously published description or diagnosis.<BR>
* A "nudum" taxon name is therefore also "invalid" ("not available" for
- * {@link ZoologicalName zoological names}).
+ * {@link IZoologicalName zoological names}).
*
* @see #isInvalidType()
*/
* {@link NonViralName#getCombinationAuthorship() author} did not definitely associate the final
* epithet with the name of the genus or species, or with its abbreviation.<BR>
* An "invalid combination" taxon name is therefore also "invalid"
- * ("not available" for {@link ZoologicalName zoological names}).
+ * ("not available" for {@link IZoologicalName zoological names}).
*
* @see #isInvalidType()
*/
/**
* Returns the nomenclatural status type "valid" (this corresponds to
- * "available" for {@link ZoologicalName zoological names}).<BR>
+ * "available" for {@link IZoologicalName zoological names}).<BR>
* A {@link TaxonNameBase taxon name} is "valid" if it:<ul>
* <li>has been effectively published and
* <li>has a form which complies with the rules of the
* is rejected by the commission but an opus with regard to the validity of
* all taxon names occurring in it.<BR>
* An "opus utique oppressum" taxon name is therefore also "invalid"
- * ("not available" for {@link ZoologicalName zoological names}).
+ * ("not available" for {@link IZoologicalName zoological names}).
*
* @see #isInvalidType()
*/
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
-import eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy;
+import eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy;
import eu.etaxonomy.cdm.validation.Level2;
import eu.etaxonomy.cdm.validation.Level3;
import eu.etaxonomy.cdm.validation.annotation.CorrectEpithetsForRank;
@NameMustHaveAuthority(groups = Level2.class)
@NoDuplicateNames(groups = Level3.class)
public class NonViralName<T extends NonViralName<?>>
- extends TaxonNameBase<T, INonViralNameCacheStrategy<T>>{
+ extends TaxonNameBase<T, INameCacheStrategy>{
private static final long serialVersionUID = -9083811681449792683L;
@Override
public Object clone() {
- NonViralName<?> result = (NonViralName<?>)super.clone();
+ INonViralName result = (INonViralName)super.clone();
//no changes to:
return result;
public abstract class TaxonNameBase<T extends TaxonNameBase<?,?>, S extends INameCacheStrategy>
extends IdentifiableEntity<S>
implements ITaxonNameBase, INonViralName, IViralName, IBacterialName, IZoologicalName,
- ICultivarPlantName,
+ IBotanicalName, ICultivarPlantName,
IParsable, IRelated, IMatchable, Cloneable {
private static final long serialVersionUID = -791164269603409712L;
@IndexedEmbedded
private Reference nomenclaturalReference;
-//****** NonViralName attributes ***************************************/
+//****** Non-ViralName attributes ***************************************/
@XmlElement(name = "NameCache")
@Fields({
* @see #addNameRelationship(NameRelationship)
*/
@Override
- public HybridRelationship addHybridParent(NonViralName parentName, HybridRelationshipType type, String ruleConsidered){
+ public HybridRelationship addHybridParent(INonViralName parentName, HybridRelationshipType type, String ruleConsidered){
return new HybridRelationship(this, parentName, type, ruleConsidered);
}
* @see #addNameRelationship(NameRelationship)
*/
@Override
- public HybridRelationship addHybridChild(NonViralName childName, HybridRelationshipType type, String ruleConsidered){
+ public HybridRelationship addHybridChild(INonViralName childName, HybridRelationshipType type, String ruleConsidered){
return new HybridRelationship(childName, this, type, ruleConsidered);
}
@Override
- public void removeHybridChild(NonViralName child) {
+ public void removeHybridChild(INonViralName child) {
Set<HybridRelationship> hybridRelationships = new HashSet<HybridRelationship>();
hybridRelationships.addAll(this.getHybridChildRelations());
hybridRelationships.addAll(this.getHybridParentRelations());
}
@Override
- public void removeHybridParent(NonViralName parent) {
+ public void removeHybridParent(INonViralName parent) {
Set<HybridRelationship> hybridRelationships = new HashSet<HybridRelationship>();
hybridRelationships.addAll(this.getHybridChildRelations());
hybridRelationships.addAll(this.getHybridParentRelations());
result = (TaxonNameBase)super.clone();
//taxonBases -> empty
- result.taxonBases = new HashSet<TaxonBase>();
+ result.taxonBases = new HashSet<>();
//empty caches
if (! protectedFullTitleCache){
}
//descriptions
- result.descriptions = new HashSet<TaxonNameDescription>();
+ result.descriptions = new HashSet<>();
for (TaxonNameDescription taxonNameDescription : getDescriptions()){
TaxonNameDescription newDescription = (TaxonNameDescription)taxonNameDescription.clone();
result.descriptions.add(newDescription);
}
//status
- result.status = new HashSet<NomenclaturalStatus>();
+ result.status = new HashSet<>();
for (NomenclaturalStatus nomenclaturalStatus : getStatus()){
NomenclaturalStatus newStatus = (NomenclaturalStatus)nomenclaturalStatus.clone();
result.status.add(newStatus);
//To Relations
- result.relationsToThisName = new HashSet<NameRelationship>();
+ result.relationsToThisName = new HashSet<>();
for (NameRelationship toRelationship : getRelationsToThisName()){
NameRelationship newRelationship = (NameRelationship)toRelationship.clone();
newRelationship.setRelatedTo(result);
}
//From Relations
- result.relationsFromThisName = new HashSet<NameRelationship>();
+ result.relationsFromThisName = new HashSet<>();
for (NameRelationship fromRelationship : getRelationsFromThisName()){
NameRelationship newRelationship = (NameRelationship)fromRelationship.clone();
newRelationship.setRelatedFrom(result);
}
//type designations
- result.typeDesignations = new HashSet<TypeDesignationBase>();
+ result.typeDesignations = new HashSet<>();
for (TypeDesignationBase<?> typeDesignation : getTypeDesignations()){
TypeDesignationBase<?> newDesignation = (TypeDesignationBase<?>)typeDesignation.clone();
result.typeDesignations.add(newDesignation);
@Audited
@Configurable
public class ViralName
- extends TaxonNameBase<ViralName, INameCacheStrategy<ViralName>> {
+ extends TaxonNameBase<ViralName, INameCacheStrategy> {
private static final long serialVersionUID = -6201649691028218290L;
// ************* CONSTRUCTORS *************/
* Returns the {@link NomenclaturalCode nomenclatural code} that governs
* the construction of <i>this</i> zoological taxon name, that is the
* International Code of Zoological Nomenclature. This method overrides
- * the getNomenclaturalCode method from {@link NonViralName NonViralName}.
+ * the getNomenclaturalCode method from {@link INonViralName NonViralName}.
*
* @return the nomenclatural code for animals
* @see NonViralName#isCodeCompliant()
*/
@Override
public Object clone() {
- ZoologicalName result = (ZoologicalName)super.clone();
+ IZoologicalName result = (IZoologicalName)super.clone();
//no changes to: breed, publicationYear, originalPublicationYear
return result;
}
\r
import eu.etaxonomy.cdm.common.AbstractStringComparator;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
\r
\r
if (name instanceof NonViralName){\r
if (logger.isTraceEnabled()){logger.trace(name + " isNonViralName");}\r
- NonViralName<?> nonViralName = (NonViralName<?>)name;\r
+ INonViralName nonViralName = name;\r
if (nonViralName.getGenusOrUninomial() != null){\r
titleCache = nonViralName.getGenusOrUninomial();\r
if (name.isSpecies() && nonViralName.getSpecificEpithet() != null){\r
import java.util.List;
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
import eu.etaxonomy.cdm.strategy.cache.TagEnum;
*
* @param <T> The concrete TaxonName class this strategy applies for
*/
-public interface INameCacheStrategy<T extends TaxonNameBase> extends IIdentifiableEntityCacheStrategy<T> {
+public interface INameCacheStrategy<T extends ITaxonNameBase> extends IIdentifiableEntityCacheStrategy<T> {
/**
* Returns a list of name typified tokens that together make up the name (including authorship etc.).
*/\r
package eu.etaxonomy.cdm.strategy.cache.name;\r
\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;\r
\r
/**\r
* A name cache rendering strategy for all TaxonNameBase subclasses.\r
*\r
* @param <T> The concrete TaxonName class this strategy applies for\r
*/\r
-public interface INonViralNameCacheStrategy<T extends TaxonNameBase> extends INameCacheStrategy<T> {\r
+public interface INonViralNameCacheStrategy<T extends ITaxonNameBase> extends INameCacheStrategy<T> {\r
\r
/**\r
* returns the last epithet of the name (i.e. uninomial if generic or above, infrageneric epithet if infrageneric,\r
import org.apache.log4j.Logger;
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;
+import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.strategy.StrategyBase;
import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
import eu.etaxonomy.cdm.strategy.cache.TaggedText;
/**
* @author AM
*/
-public abstract class NameCacheStrategyBase<T extends TaxonNameBase> extends StrategyBase implements INameCacheStrategy<T> {
+public abstract class NameCacheStrategyBase<T extends ITaxonNameBase> extends StrategyBase implements INameCacheStrategy<T> {
+ private static final long serialVersionUID = -2322348388258675517L;
+
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(NameCacheStrategyBase.class);
* existing methods, e.g. a CacheStrategy for zoological names should overwrite getAuthorAndExAuthor
* @author a.mueller
*/
-public class NonViralNameDefaultCacheStrategy<T extends NonViralName<?>>
+public class NonViralNameDefaultCacheStrategy<T extends INonViralName>
extends NameCacheStrategyBase<T>
implements INonViralNameCacheStrategy<T> {
private static final Logger logger = Logger.getLogger(NonViralNameDefaultCacheStrategy.class);
* Factory method
* @return NonViralNameDefaultCacheStrategy A new instance of NonViralNameDefaultCacheStrategy
*/
- public static <T extends NonViralName<?>> NonViralNameDefaultCacheStrategy<T> NewInstance(Class<T> clazz){
+ public static <T extends INonViralName> NonViralNameDefaultCacheStrategy<T> NewInstance(Class<T> clazz){
return new NonViralNameDefaultCacheStrategy<T>();
}
* @param nonViralName
* @return
*/
- protected boolean nameIncludesAuthorship(NonViralName<?> nonViralName){
+ protected boolean nameIncludesAuthorship(INonViralName nonViralName){
Rank rank = nonViralName.getRank();
if (rank != null && rank.isSpeciesAggregate()){
return false;
* @param nonViralName
* @return
*/
- protected List<TaggedText> getRanklessTaggedNameCache(NonViralName<?> nonViralName){
+ protected List<TaggedText> getRanklessTaggedNameCache(INonViralName nonViralName){
List<TaggedText> tags = getUninomialTaggedPart(nonViralName);
String speciesEpi = CdmUtils.Nz(nonViralName.getSpecificEpithet()).trim();
if (StringUtils.isNotBlank(speciesEpi)){
* @param nonViralName
* @return
*/
- protected List<TaggedText> getGenusOrUninomialTaggedNameCache(NonViralName<?> nonViralName){
+ protected List<TaggedText> getGenusOrUninomialTaggedNameCache(INonViralName nonViralName){
List<TaggedText> tags = getUninomialTaggedPart(nonViralName);
addAppendedTaggedPhrase(tags, nonViralName);
return tags;
* @param includeMarker
* @return
*/
- protected List<TaggedText> getInfraSpeciesTaggedNameCache(NonViralName<?> nonViralName, boolean includeMarker){
+ protected List<TaggedText> getInfraSpeciesTaggedNameCache(INonViralName nonViralName, boolean includeMarker){
List<TaggedText> tags = getGenusAndSpeciesTaggedPart(nonViralName);
if (includeMarker || nonViralName.isTrinomHybrid()){
String marker = (nonViralName.getRank().getAbbreviation()).trim().replace("null", "");
/**
* Copyright (C) 2007 EDIT
-* European Distributed Institute of Taxonomy
+* 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 eu.etaxonomy.cdm.common.CdmUtils;
import eu.etaxonomy.cdm.model.agent.INomenclaturalAuthor;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.strategy.cache.TaggedText;
-public class ZooNameDefaultCacheStrategy extends NonViralNameDefaultCacheStrategy<ZoologicalName> implements INonViralNameCacheStrategy<ZoologicalName> {
+public class ZooNameDefaultCacheStrategy
+ extends NonViralNameDefaultCacheStrategy<IZoologicalName> {
+
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(ZooNameDefaultCacheStrategy.class);
private static final long serialVersionUID = 6640953957903705560L;
final static UUID uuid = UUID.fromString("950c4236-8156-4675-b866-785df33bc4d9");
protected String AuthorYearSeperator = ", ";
-
+
@Override
public UUID getUuid(){
return uuid;
}
-
-
+
+
/**
* Factory method
* @return
public static ZooNameDefaultCacheStrategy NewInstance(){
return new ZooNameDefaultCacheStrategy();
}
-
+
/**
* Constructor
*/
public void setAuthorYearSeperator(String authorYearSeperator) {
AuthorYearSeperator = authorYearSeperator;
}
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy#getNonCacheAuthorshipCache(eu.etaxonomy.cdm.model.name.NonViralName)
- */
+
@Override
- protected String getNonCacheAuthorshipCache(ZoologicalName nonViralName) {
+ protected String getNonCacheAuthorshipCache(IZoologicalName nonViralName) {
if (nonViralName == null){
return null;
}
}
return result;
}
-
+
@Override
- protected List<TaggedText> getInfraSpeciesTaggedNameCache(ZoologicalName nonViralName){
+ protected List<TaggedText> getInfraSpeciesTaggedNameCache(IZoologicalName nonViralName){
boolean includeMarker = ! (nonViralName.isAutonym());
return getInfraSpeciesTaggedNameCache(nonViralName, includeMarker);
}
import org.apache.log4j.Logger;\r
\r
import eu.etaxonomy.cdm.model.name.INonViralName;\r
-import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.strategy.cache.TagEnum;\r
import eu.etaxonomy.cdm.strategy.cache.TaggedText;\r
\r
\r
\r
@Override\r
- protected List<TaggedText> getInfraSpeciesTaggedNameCache(ZoologicalName nonViralName){\r
+ protected List<TaggedText> getInfraSpeciesTaggedNameCache(IZoologicalName nonViralName){\r
boolean includeMarker = false;\r
return getInfraSpeciesTaggedNameCache(nonViralName, includeMarker);\r
}\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
}
@Override
- public NonViralName parseSimpleName(String simpleName){
+ public INonViralName parseSimpleName(String simpleName){
return parseSimpleName(simpleName, null, null);
}
@Override
- public NonViralName parseSimpleName(String simpleName, NomenclaturalCode code, Rank rank){
+ public INonViralName parseSimpleName(String simpleName, NomenclaturalCode code, Rank rank){
//"parseSimpleName() not yet implemented. Uses parseFullName() instead");
return parseFullName(simpleName, code, rank);
}
- public void parseSimpleName(NonViralName nameToBeFilled, String simpleNameString, Rank rank, boolean makeEmpty){
+ public void parseSimpleName(INonViralName nameToBeFilled, String simpleNameString, Rank rank, boolean makeEmpty){
//"parseSimpleName() not yet implemented. Uses parseFullName() instead");
parseFullName(nameToBeFilled, simpleNameString, rank, makeEmpty);
}
- public NonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code){
+ public INonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code){
return getNonViralNameInstance(fullString, code, null);
}
- public NonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code, Rank rank){
- NonViralName<?> result = null;
+ public INonViralName getNonViralNameInstance(String fullString, NomenclaturalCode code, Rank rank){
+ INonViralName result = null;
if(code ==null) {
boolean isBotanicalName = anyBotanicFullNamePattern.matcher(fullString).find();
boolean isZoologicalName = anyZooFullNamePattern.matcher(fullString).find();;
if (fullReferenceString == null){
return null;
}else{
- NonViralName<?> result = getNonViralNameInstance(fullReferenceString, nomCode, rank);
+ INonViralName result = getNonViralNameInstance(fullReferenceString, nomCode, rank);
parseReferencedName(result, fullReferenceString, rank, MAKE_EMPTY);
- return result;
+ return (NonViralName)result;
}
}
//zoological new combinations should not have a nom. reference to be parsed
if (nameToBeFilled.isInstanceOf(ZoologicalName.class)){
- ZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);
+ IZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);
//is name new combination?
if (zooName.getBasionymAuthorship() != null || zooName.getOriginalPublicationYear() != null){
ParserProblem parserProblem = ParserProblem.NewCombinationHasPublication;
yearPart = yearPart.replaceFirst(pStart + yearSeperator, "").trim();
}else{
if (nameToBeFilled.isInstanceOf(ZoologicalName.class)){
- ZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);
+ IZoologicalName zooName = CdmBase.deproxy(nameToBeFilled, ZoologicalName.class);
yearPart = String.valueOf(zooName.getPublicationYear());
//continue
}else{
}
@Override
- public NonViralName parseFullName(String fullNameString){
+ public INonViralName parseFullName(String fullNameString){
return parseFullName(fullNameString, null, null);
}
@Override
- public NonViralName parseFullName(String fullNameString, NomenclaturalCode nomCode, Rank rank) {
+ public INonViralName parseFullName(String fullNameString, NomenclaturalCode nomCode, Rank rank) {
if (fullNameString == null){
return null;
}else{
- NonViralName<?> result = getNonViralNameInstance(fullNameString, nomCode, rank);
+ INonViralName result = getNonViralNameInstance(fullNameString, nomCode, rank);
parseFullName(result, fullNameString, rank, false);
return result;
}
}
nameToBeFilled.setHybridFormula(true);
NomenclaturalCode code = nameToBeFilled.getNomenclaturalCode();
- NonViralName<?> firstName = this.parseFullName(firstNameString.trim(), code, rank);
- NonViralName<?> secondName = this.parseFullName(secondNameString.trim(), code, rank);
+ INonViralName firstName = this.parseFullName(firstNameString.trim(), code, rank);
+ INonViralName secondName = this.parseFullName(secondNameString.trim(), code, rank);
HybridRelationship firstRel = nameToBeFilled.addHybridParent(firstName, HybridRelationshipType.FIRST_PARENT(), null);
HybridRelationship second = nameToBeFilled.addHybridParent(secondName, HybridRelationshipType.SECOND_PARENT(), null);
checkRelationExist(firstRel, existingRelations, notToBeDeleted);
nonViralName.setBasionymAuthorship(authors[2]);
nonViralName.setExBasionymAuthorship(authors[3]);
if (nonViralName instanceof ZoologicalName){
- ZoologicalName zooName = CdmBase.deproxy(nonViralName, ZoologicalName.class);
+ IZoologicalName zooName = CdmBase.deproxy(nonViralName, ZoologicalName.class);
zooName.setPublicationYear(years[0]);
zooName.setOriginalPublicationYear(years[2]);
}
nameToBeFilled.setBasionymAuthorship(authors[2]);
nameToBeFilled.setExBasionymAuthorship(authors[3]);
if (nameToBeFilled instanceof ZoologicalName){
- ZoologicalName zooName = (ZoologicalName)nameToBeFilled;
+ IZoologicalName zooName = (ZoologicalName)nameToBeFilled;
zooName.setPublicationYear(years[0]);
zooName.setOriginalPublicationYear(years[2]);
}
}
if (nameToBeFilled.isInstanceOf(ZoologicalName.class)){
- ZoologicalName zoologicalName = (ZoologicalName)nameToBeFilled;
+ IZoologicalName zoologicalName = (ZoologicalName)nameToBeFilled;
zoologicalName.setBreed(null);
zoologicalName.setOriginalPublicationYear(null);
}
/**\r
* Copyright (C) 2007 EDIT\r
-* European Distributed Institute of Taxonomy \r
+* European Distributed Institute of Taxonomy\r
* http://www.e-taxonomy.eu\r
-* \r
+*\r
* The contents of this file are subject to the Mozilla Public License Version 1.1\r
* See LICENSE.TXT at the top of this package for the full license terms.\r
*/\r
RankNotSupported(ERROR()),\r
NewCombinationHasPublication(WARNING()),\r
;\r
- \r
- //logger.warn("ICNCP parsing not yet implemented");\r
- //logger.warn("ICNB not yet implemented");\r
- //logger.error("Viral name is not a NonViralName !!");\r
- //logger.error("Unknown Nomenclatural Code !!");\r
- //logger.warn("nameToBeFilled class not supported ("+nameToBeFilled.getClass()+")");\r
- \r
+\r
@SuppressWarnings("unused")\r
private static final Logger logger = Logger.getLogger(ParserProblem.class);\r
- \r
+\r
private final static int WARNING(){return 0;};\r
private final static int ERROR() {return 1;};\r
- \r
- int type; \r
- \r
+\r
+ int type;\r
+\r
private ParserProblem(int type){\r
this.type = type;\r
}\r
- \r
+\r
public String getMessage(){\r
return getMessage(Language.DEFAULT());\r
}\r
- \r
+\r
public String getMessage(Language language){\r
//TODO language not yet supported\r
if (this == CheckRank){\r
return "unknown parser problem";\r
}\r
}\r
- \r
- \r
+\r
+\r
public boolean isError(){\r
return type == ERROR();\r
}\r
return type == WARNING();\r
}\r
\r
- \r
+\r
public static List<ParserProblem> warningList(int problem){\r
List<ParserProblem> result = new ArrayList<ParserProblem>();\r
ParserProblem[] values = ParserProblem.values();\r
}\r
return result;\r
}\r
- \r
+\r
public static boolean hasError(int problem){\r
List<ParserProblem> list = warningList(problem);\r
for (ParserProblem warning : list){\r
return originalProblems | 1 << newProblem.ordinal();\r
}\r
}\r
- \r
+\r
public static int addProblems(int hasProblem, int newProblems) {\r
return hasProblem | newProblems;\r
}\r
}else{\r
return originalProblems & ~(1 << problemToRemove.ordinal());\r
}\r
- } \r
+ }\r
+\r
+\r
\r
- \r
- \r
}\r
import javax.validation.ConstraintValidatorContext;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NonViralName;
TaxonNameBase<?,?> to = CdmBase.deproxy(nameRelationship.getToName(), TaxonNameBase.class);
if(from instanceof NonViralName && to instanceof NonViralName) {
- NonViralName<?> fromName = (NonViralName<?>) from;
- NonViralName<?> toName = (NonViralName<?>) to;
+ INonViralName fromName = from;
+ INonViralName toName = to;
//compare author teams
if(fromName.getCombinationAuthorship() == null || !fromName.getCombinationAuthorship().equals(toName.getBasionymAuthorship())) {
\r
import eu.etaxonomy.cdm.common.CdmUtils;\r
import eu.etaxonomy.cdm.model.common.CdmBase;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
TaxonNameBase<?,?> parentNameBase = CdmBase.deproxy(parent.getName(), TaxonNameBase.class);\r
TaxonNameBase<?,?> childNameBase = CdmBase.deproxy(child.getName(), TaxonNameBase.class);\r
if(parentNameBase instanceof NonViralName && childNameBase instanceof NonViralName) {\r
- NonViralName<?> parentName = (NonViralName<?>)parentNameBase;\r
- NonViralName<?> childName = (NonViralName<?>)childNameBase;\r
+ INonViralName parentName = parentNameBase;\r
+ INonViralName childName = childNameBase;\r
\r
if(childName.isSpecies() || childName.isInfraSpecific()) {\r
if(! CdmUtils.nullSafeEqual(parentName.getGenusOrUninomial(), childName.getGenusOrUninomial())) {\r
\r
import org.apache.commons.lang.StringUtils;\r
\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
import eu.etaxonomy.cdm.validation.annotation.CorrectEpithetsForRank;\r
\r
-public class CorrectEpithetsForRankValidator implements ConstraintValidator<CorrectEpithetsForRank, NonViralName<?>> {\r
+public class CorrectEpithetsForRankValidator implements ConstraintValidator<CorrectEpithetsForRank, INonViralName> {\r
\r
@Override\r
public void initialize(CorrectEpithetsForRank correctEpithetsForRank) { }\r
\r
@Override\r
- public boolean isValid(NonViralName<?> name, ConstraintValidatorContext constraintContext) {\r
+ public boolean isValid(INonViralName name, ConstraintValidatorContext constraintContext) {\r
boolean valid = true;\r
if(name.isSupraGeneric() || name.isGenus()) {\r
if(isNotBlank(name.getInfraGenericEpithet())) {\r
import javax.validation.ConstraintValidatorContext;
import eu.etaxonomy.cdm.model.name.BotanicalName;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.validation.annotation.NameMustHaveAuthority;
public class MustHaveAuthorityValidator implements
- ConstraintValidator<NameMustHaveAuthority, NonViralName<?>> {
+ ConstraintValidator<NameMustHaveAuthority, INonViralName> {
@Override
public void initialize(NameMustHaveAuthority mustHaveAuthority) { }
@Override
- public boolean isValid(NonViralName<?> name, ConstraintValidatorContext constraintContext) {
+ public boolean isValid(INonViralName name, ConstraintValidatorContext constraintContext) {
boolean valid = true;
if(name.getBasionymAuthorship() == null && name.getAuthorshipCache() == null) {
import eu.etaxonomy.cdm.model.NewEntityListener;
import eu.etaxonomy.cdm.model.common.Annotation;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
public void testPropertyChange() {
CdmBase.setNewEntityListener(this);
- NonViralName<?> nvn = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
Annotation newAnnotation = Annotation.NewDefaultLanguageInstance("test");
- nvn.addAnnotation(newAnnotation);
+ b.addAnnotation(newAnnotation);
Assert.assertEquals(newAnnotation, lastPropValue);
}
import org.junit.Test;
import eu.etaxonomy.cdm.model.name.BotanicalName;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
@Test
public void testPropertyChange() {
- NonViralName<?> b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- b.addPropertyChangeListener(this);
+ INonViralName b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ ((TaxonNameBase<?,?>)b).addPropertyChangeListener(this);
b.setGenusOrUninomial("Abies");
assertEquals(b.getGenusOrUninomial(), lastPropValue);
b.setGenusOrUninomial("Picea");
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
citationRef.setTitleCache("Sp. lunarum", true);
//genus taxon with Name, combinationAuthor,
- BotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
botName.setTitleCache("Hieracium L.", true);
botName.setGenusOrUninomial("Hieracium");
botName.setCombinationAuthorship(Person.NewInstance());
import org.junit.Test;\r
\r
import eu.etaxonomy.cdm.model.agent.Person;\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
*/\r
public class IdentifiableEntityTest {\r
\r
- private NonViralName<?> abies;\r
- private NonViralName<?> abiesMill;\r
- private NonViralName<?> abiesAlba;\r
- private NonViralName<?> abiesAlbaMichx;\r
- private NonViralName<?> abiesAlbaMill;\r
- private NonViralName<?> abiesAlbaxPinusBeta;\r
- private NonViralName<?> pinusBeta;\r
+ private TaxonNameBase<?,?> abies;\r
+ private TaxonNameBase<?,?> abiesMill;\r
+ private TaxonNameBase<?,?> abiesAlba;\r
+ private TaxonNameBase<?,?> abiesAlbaMichx;\r
+ private TaxonNameBase<?,?> abiesAlbaMill;\r
+ private TaxonNameBase<?,?> abiesAlbaxPinusBeta;\r
+ private TaxonNameBase<?,?> pinusBeta;\r
\r
private Taxon abiesTaxon;\r
private Taxon abiesMillTaxon;\r
\r
- private NonViralName<?> abiesAutonym;\r
+ private TaxonNameBase<?,?> abiesAutonym;\r
private Taxon abiesAutonymTaxon;\r
\r
- private NonViralName<?> abiesBalsamea;\r
+ private TaxonNameBase<?,?> abiesBalsamea;\r
private Taxon abiesBalsameaTaxon;\r
// private Taxon abiesAlbaxPinusBetaTaxon;\r
/**\r
assertEquals(compareResult, equalsResult);\r
\r
//Abies alba x Pinus beta < Abies alba xinus\r
- BotanicalName abiesAlbaXinus = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());\r
+ TaxonNameBase<?,?> abiesAlbaXinus = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());\r
abiesAlbaXinus.setGenusOrUninomial("Abies");\r
abiesAlbaXinus.setSpecificEpithet("alba");\r
abiesAlbaXinus.setInfraSpecificEpithet("xinus");\r
@SuppressWarnings("unused")\r
private static final Logger logger = Logger.getLogger(BacterialNameTest.class);\r
\r
- private BacterialName bacterialName1;\r
+ private IBacterialName bacterialName1;\r
\r
/**\r
* @throws java.lang.Exception\r
public void testClone() {\r
bacterialName1.setSubGenusAuthorship("Bacter.");\r
bacterialName1.setNameApprobation("approb");\r
- BacterialName clone = (BacterialName)bacterialName1.clone();\r
+ IBacterialName clone = (IBacterialName)bacterialName1.clone();\r
Assert.assertEquals("SubGenusAuthorship should be equal", "Bacter.", clone.getSubGenusAuthorship());\r
Assert.assertEquals("Name approbation should be equal", "approb", clone.getNameApprobation());\r
}\r
@Test
public final void testPARSED_NAME() {
String fullName = "Abies alba subsp. beta (L.) Mill.";
- BotanicalName name = TaxonNameFactory.PARSED_BOTANICAL(fullName);
+ IBotanicalName name = TaxonNameFactory.PARSED_BOTANICAL(fullName);
assertFalse(name.hasProblem());
assertEquals("beta", name.getInfraSpecificEpithet());
}
@Test
public final void testBotanicalNameRank() {
Rank genus = Rank.GENUS();
- BotanicalName rankName = TaxonNameFactory.NewBotanicalInstance(genus);
+ IBotanicalName rankName = TaxonNameFactory.NewBotanicalInstance(genus);
assertNotNull(rankName);
assertSame(genus, rankName.getRank());
assertTrue(rankName.getRank().isGenus());
- BotanicalName nullRankName = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName nullRankName = TaxonNameFactory.NewBotanicalInstance(null);
assertNotNull(nullRankName);
assertNull(nullRankName.getRank());
}
INomenclaturalReference nomenclaturalReference = ReferenceFactory.newArticle();
String nomenclMicroRef = "microRef";
HomotypicalGroup homotypicalGroup = new HomotypicalGroup();
- BotanicalName fullName = new BotanicalName(rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);
+ IBotanicalName fullName = new BotanicalName(rank, genusOrUninomial, infraGenericEpithet, specificEpithet, infraSpecificEpithet, combinationAuthorship, nomenclaturalReference, nomenclMicroRef, homotypicalGroup);
assertEquals(Rank.SPECIALFORM(), fullName.getRank());
assertEquals("Genus", fullName.getGenusOrUninomial());
assertEquals("infraGenericEpi", fullName.getInfraGenericEpithet());
private static Logger logger = Logger.getLogger(NonViralNameTest.class);
- NonViralName<?> nonViralName1;
- NonViralName<?> nonViralName2;
+ INonViralName nonViralName1;
+ INonViralName nonViralName2;
@BeforeClass
public static void setUpBeforeClass() {
*/
@Test
public final void testNonViralNameRank() {
- NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());
+ INonViralName nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());
assertNotNull(nonViralName);
}
Team agent = Team.NewInstance();
INomenclaturalReference article = ReferenceFactory.newArticle();
HomotypicalGroup homotypicalGroup = HomotypicalGroup.NewInstance();
- NonViralName<?> nonViralName = new NonViralName<>(Rank.GENUS(), "Genus", "infraGen", "species", "infraSpec", agent, article, "mikro", homotypicalGroup);
+ INonViralName nonViralName = new NonViralName(Rank.GENUS(), "Genus", "infraGen", "species", "infraSpec", agent, article, "mikro", homotypicalGroup);
assertEquals("Genus", nonViralName.getGenusOrUninomial() );
assertEquals("infraGen", nonViralName.getInfraGenericEpithet());
assertEquals("species", nonViralName.getSpecificEpithet() );
@Test
public final void testGetChildAndParentRelationships() {
- NonViralName<?> nonViralName1 = new NonViralName<>();
+ INonViralName nonViralName1 = TaxonNameFactory.NewNonViralInstance(null);
assertEquals(0, nonViralName1.getHybridParentRelations().size());
assertEquals(0, nonViralName1.getHybridChildRelations().size());
- BotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
HybridRelationship hybridRelationship = new HybridRelationship(nonViralName1, femaleParent, HybridRelationshipType.FEMALE_PARENT(), null );
assertEquals(1, nonViralName1.getHybridChildRelations().size());
assertEquals(hybridRelationship, nonViralName1.getHybridChildRelations().iterator().next());
@Test
public final void testAddHybridRelationships() {
- NonViralName<?> nonViralName1 = new NonViralName();
+ INonViralName nonViralName1 = TaxonNameFactory.NewNonViralInstance(null);
assertEquals(0, nonViralName1.getHybridParentRelations().size());
assertEquals(0, nonViralName1.getHybridChildRelations().size());
- BotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
- BotanicalName maleParent = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName maleParent = TaxonNameFactory.NewBotanicalInstance(null);
nonViralName1.addHybridParent(femaleParent, HybridRelationshipType.MALE_PARENT(), null);
nonViralName1.addHybridParent(maleParent, HybridRelationshipType.MALE_PARENT(), null);
@Test(expected=IllegalArgumentException.class)
public final void testAddHybridRelationship() {
- NonViralName<?> nonViralName1 = new NonViralName();
+ INonViralName nonViralName1 = TaxonNameFactory.NewNonViralInstance(null);
assertEquals(0, nonViralName1.getHybridParentRelations().size());
assertEquals(0, nonViralName1.getHybridChildRelations().size());
- NonViralName<?> botanicalName2 = new NonViralName();
+ TaxonNameBase<?,?> botanicalName2 = TaxonNameFactory.NewNonViralInstance(null);
botanicalName2.addHybridRelationship(null);
}
@Test
public final void testRemoveHybridRelationship() {
- NonViralName<?> botanicalName1 = new NonViralName();
+ INonViralName botanicalName1 = TaxonNameFactory.NewNonViralInstance(null);
assertEquals(0, botanicalName1.getHybridParentRelations().size());
assertEquals(0, botanicalName1.getHybridChildRelations().size());
- BotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
- NonViralName<?> maleParent = TaxonNameFactory.NewNonViralInstance(null);
- ZoologicalName child = TaxonNameFactory.NewZoologicalInstance(null);
+ IBotanicalName femaleParent = TaxonNameFactory.NewBotanicalInstance(null);
+ TaxonNameBase<?,?> maleParent = TaxonNameFactory.NewNonViralInstance(null);
+ IZoologicalName child = TaxonNameFactory.NewZoologicalInstance(null);
botanicalName1.addHybridParent(femaleParent, HybridRelationshipType.FEMALE_PARENT(), null);
botanicalName1.addHybridParent(maleParent, HybridRelationshipType.MALE_PARENT(), null);
nonViralName1.setInfraSpecificEpithet("infrabus");
nonViralName1.setBinomHybrid(true);
- NonViralName<?> parent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> parent2 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> child = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> child2 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName parent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName parent2 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName child = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName child2 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
nonViralName1.addHybridParent(parent, HybridRelationshipType.FIRST_PARENT(), "parent rule");
nonViralName1.addHybridParent(parent2, HybridRelationshipType.SECOND_PARENT(), "parent rule2");
nonViralName1.addHybridChild(child, HybridRelationshipType.FEMALE_PARENT(), "child rule");
- INonViralName clone = (INonViralName)nonViralName1.clone();
+ INonViralName clone = (INonViralName)((NonViralName)nonViralName1).clone();
Assert.assertEquals("Genus should be equal", "Aus", clone.getGenusOrUninomial());
Assert.assertEquals("Infragenus should be equal", "Infaus", clone.getInfraGenericEpithet());
Assert.assertEquals("Specific epithet should be equal", "bus", clone.getSpecificEpithet());
\r
@Test\r
public void testClone(){\r
- NonViralName taxonNameBase1 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
- NonViralName<?> genusName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());\r
- Taxon taxonBase = Taxon.NewInstance(taxonNameBase1, null);\r
+ TaxonNameBase<?,?> taxonNameBase1 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ TaxonNameBase<?,?> genusName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());\r
+ Taxon.NewInstance(taxonNameBase1, null);\r
\r
//basionym & homonym\r
- NonViralName<?> basionym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
- NonViralName<?> earlierHomonym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ TaxonNameBase<?,?> basionym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ TaxonNameBase<?,?> earlierHomonym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
taxonNameBase1.addBasionym(basionym);\r
taxonNameBase1.addRelationshipToName(earlierHomonym, NameRelationshipType.LATER_HOMONYM(), "later homonym rule");\r
//status\r
description.addElement(textData);\r
\r
//CLONE\r
- TaxonNameBase<?,?> clone = (TaxonNameBase)taxonNameBase1.clone();\r
- TaxonNameBase<?,?> genusClone = (TaxonNameBase)genusName.clone();\r
+ TaxonNameBase<?,?> clone = (TaxonNameBase<?,?>)taxonNameBase1.clone();\r
+ TaxonNameBase<?,?> genusClone = (TaxonNameBase<?,?>)genusName.clone();\r
assertSame("Rank should be same", taxonNameBase1.getRank(), clone.getRank());\r
assertTrue("TaxonBases should not be cloned", clone.getTaxonBases().isEmpty());\r
assertEquals("TaxonBases of original name should not be empty", 1, taxonNameBase1.getTaxonBases().size());\r
@SuppressWarnings("unused")\r
private static final Logger logger = Logger.getLogger(ZoologicalNameTest.class);\r
\r
- private ZoologicalName zooName1;\r
+ private IZoologicalName zooName1;\r
\r
/**\r
* @throws java.lang.Exception\r
zooName1.setBreed("breed");\r
zooName1.setPublicationYear(1956);\r
zooName1.setOriginalPublicationYear(1867);\r
- ZoologicalName clone = (ZoologicalName)zooName1.clone();\r
+ IZoologicalName clone = (IZoologicalName)zooName1.clone();\r
Assert.assertEquals("Breed should be equal", "breed", clone.getBreed());\r
Assert.assertEquals("Publication year should be equal", Integer.valueOf(1956), clone.getPublicationYear());\r
Assert.assertEquals("Original publication year should be equal", Integer.valueOf(1867), clone.getOriginalPublicationYear());\r
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
//genericDao.getCdmBasesByFieldAndClass(clazz, field.getName(), value);
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonNameBase<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
name.setTitleCache("A dummy name", true);
result.add(name);
Reference ref = ReferenceFactory.newBook();
import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
//import eu.etaxonomy.cdm.model.reference.Book;
}
- private void setNameParts(NonViralName<?> name, String genus, String speciesEpi) {
+ private void setNameParts(INonViralName name, String genus, String speciesEpi) {
name.setGenusOrUninomial(genus);
name.setSpecificEpithet(speciesEpi);
name.getTitleCache();
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
-import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
import eu.etaxonomy.cdm.test.unit.EntityTestBase;\r
private static final Logger logger = Logger.getLogger(TaxonBaseTest.class);\r
\r
private Reference sec;\r
- private ZoologicalName name1;\r
+ private IZoologicalName name1;\r
private BotanicalName name2;\r
private Taxon rootT;\r
private Taxon taxon1;\r
\r
public final void testClone(){\r
\r
- BotanicalName test = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());\r
+ TaxonNameBase<?,?> test = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());\r
String genus = "test";\r
String infraGenericEpithet = "test";\r
test.setGenusOrUninomial(genus);\r
import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.name.ZoologicalName;
BotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(null);
BotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(null);
BotanicalName botName3 = TaxonNameFactory.NewBotanicalInstance(null);
- ZoologicalName zooName1 = TaxonNameFactory.NewZoologicalInstance(null);
+ IZoologicalName zooName1 = TaxonNameFactory.NewZoologicalInstance(null);
botName1.setNomenclaturalReference(ref1);
botName2.setNomenclaturalReference(ref2);
import org.junit.Test;
import org.springframework.beans.BeanUtils;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
* `- Pinus pampa subsp. persicifolia
*/
Classification classification = Classification.NewInstance("Classification");
- BotanicalName pinusName = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName pinusName = TaxonNameFactory.NewBotanicalInstance(null);
pinusName.setGenusOrUninomial("Pinus");
Taxon pinus = Taxon.NewInstance(pinusName, null);
- BotanicalName pinusPampaName = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName pinusPampaName = TaxonNameFactory.NewBotanicalInstance(null);
pinusPampaName.setGenusOrUninomial("Pinus");
pinusPampaName.setSpecificEpithet("pampa");
Taxon pinusPampa = Taxon.NewInstance(pinusPampaName, null);
- BotanicalName pinusPampaSubName = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName pinusPampaSubName = TaxonNameFactory.NewBotanicalInstance(null);
pinusPampaSubName.setGenusOrUninomial("Pinus");
pinusPampaSubName.setSpecificEpithet("pampa");
pinusPampaSubName.setInfraSpecificEpithet("persicifolia");
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-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;
private Reference sec;
private Reference misSec;
- private ZoologicalName name1;
+ private IZoologicalName name1;
private BotanicalName name2;
private Taxon rootT;
private Taxon child1;
import org.junit.Test;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
@Test
public void testGetTitleCache(){
- BotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
botName.setGenusOrUninomial("Genus");
botName.setSpecificEpithet("species");
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(NonViralNameDefaultCacheStrategyTest.class);
- private NonViralNameDefaultCacheStrategy<NonViralName<?>> strategy;
+ private NonViralNameDefaultCacheStrategy<INonViralName> strategy;
private static final String familyNameString = "Familia";
private static final String genusNameString = "Genus";
@Test
public void testGattungsAutonyme() {
- BotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.SECTION_BOTANY());
+ IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.SECTION_BOTANY());
String strTaraxacum = "Traxacum";
botName.setGenusOrUninomial(strTaraxacum);
botName.setInfraGenericEpithet(strTaraxacum);
Assert.assertEquals("", "Genus subsect. Infragenus", botName.getNameCache());
//zool. specific ranks (we don't have markers here therefore no problem should exist
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SECTION_ZOOLOGY());
+ IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SECTION_ZOOLOGY());
zooName.setGenusOrUninomial("Genus");
zooName.setInfraGenericEpithet("Infragenus");
Assert.assertEquals("", "Genus", zooName.getNameCache());
Assert.assertEquals(author.getNomenclaturalTitle(), speciesName.getAuthorshipCache());
Assert.assertEquals("Should be 'Abies alba L.'", "Abies alba L.", speciesName.getTitleCache());
- NonViralName<?> hybridName = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> secondParent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName hybridName = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName secondParent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
secondParent.setTitleCache("Second parent Mill.", true);
hybridName.addHybridParent(speciesName, HybridRelationshipType.FIRST_PARENT(), null);
@Test
public void testOriginalSpelling() {
NameRelationshipType origSpellingType = NameRelationshipType.ORIGINAL_SPELLING();
- NonViralName<?> originalName = (NonViralName<?>)speciesName.clone();
+ TaxonNameBase<?,?> originalName = (TaxonNameBase<?,?>)speciesName.clone();
originalName.setSpecificEpithet("alpa");
Assert.assertEquals("Preconditions are wrong", "Abies alpa", originalName.getNameCache());
Assert.assertNotNull("TitleCache should not be null", subSpeciesName.getTitleCache());
//year
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
zooName.setGenusOrUninomial("Homo");
zooName.setSpecificEpithet("sapiens");
zooName.setBasionymAuthorship(basAuthor);
@Test
public void testGetInfraGenericNames(){
String author = "Anyauthor";
- NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.SUBGENUS());
+ INonViralName nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.SUBGENUS());
nonViralName.setGenusOrUninomial("Genus");
nonViralName.setInfraGenericEpithet("subgenus");
nonViralName.setAuthorshipCache(author);
@Test //#2888
public void testAutonymWithExAuthor(){
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.FORM());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.FORM());
name.setGenusOrUninomial("Euphorbia");
name.setSpecificEpithet("atropurpurea");
name.setInfraSpecificEpithet("atropurpurea");
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
/**
* @author a.mueller
private static final Logger logger = Logger.getLogger(ZooNameNoMarkerCacheStrategyTest.class);
private ZooNameDefaultCacheStrategy strategy;
- private ZoologicalName familyName;
- private ZoologicalName genusName;
- private ZoologicalName subGenusName;
- private ZoologicalName speciesName;
- private ZoologicalName subSpeciesName;
+ private IZoologicalName familyName;
+ private IZoologicalName subGenusName;
+ private IZoologicalName speciesName;
+ private TaxonNameBase<?,ZooNameDefaultCacheStrategy> subSpeciesName;
private TeamOrPersonBase<?> author;
private TeamOrPersonBase<?> exAuthor;
private TeamOrPersonBase<?> basAuthor;
public void setUp() throws Exception {
strategy = ZooNameNoMarkerCacheStrategy.NewInstance();
familyName = TaxonNameFactory.PARSED_ZOOLOGICAL(familyNameString, Rank.FAMILY());
- genusName = TaxonNameFactory.PARSED_ZOOLOGICAL(genusNameString, Rank.GENUS());
subGenusName = TaxonNameFactory.NewZoologicalInstance(Rank.SUBGENUS());
subGenusName.setGenusOrUninomial("Genus");
subGenusName.setInfraGenericEpithet("InfraGenericPart");
speciesName = TaxonNameFactory.PARSED_ZOOLOGICAL(speciesNameString);
- subSpeciesName = TaxonNameFactory.PARSED_ZOOLOGICAL(subSpeciesNameStringToParse);
+ subSpeciesName =(TaxonNameBase) TaxonNameFactory.PARSED_ZOOLOGICAL(subSpeciesNameStringToParse);
subSpeciesName.setCacheStrategy(strategy);
author = Person.NewInstance();
import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
/**
* @author a.mueller
private static final Logger logger = Logger.getLogger(ZoologicalNameCacheStrategyTest.class);
private ZooNameDefaultCacheStrategy strategy;
- private ZoologicalName familyName;
- private ZoologicalName genusName;
- private ZoologicalName subGenusName;
- private ZoologicalName speciesName;
- private ZoologicalName subSpeciesName;
- private ZoologicalName speciesNameWithInfrGenEpi;
+ private IZoologicalName familyName;
+ private IZoologicalName genusName;
+ private IZoologicalName subGenusName;
+ private IZoologicalName speciesName;
+ private IZoologicalName subSpeciesName;
+ private IZoologicalName speciesNameWithInfrGenEpi;
private TeamOrPersonBase<?> author;
private TeamOrPersonBase<?> exAuthor;
private TeamOrPersonBase<?> basAuthor;
import eu.etaxonomy.cdm.model.location.Point;
import eu.etaxonomy.cdm.model.location.ReferenceSystem;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.IBook;
Assert.assertTrue("Cached book with a defined and a null edition should match", matchStrategy.invoke(book1, bookClone));
matchStrategy = DefaultMatchStrategy.NewInstance(BotanicalName.class);
- BotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
- BotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
Assert.assertNotNull("Rank should not be null", botName1.getRank());
botName1.setGenusOrUninomial("Genus1");
BotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
BotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
- BotanicalName botName3 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName botName3 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
Assert.assertFalse("Names without title should not match", matchStrategy.invoke(botName1, botName2));
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;\r
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
@Test\r
public final void testTeamSeperation(){\r
Rank speciesRank = Rank.SPECIES();\r
- NonViralName<?> name;\r
+ INonViralName name;\r
\r
// String strNameWith1AUthorAndCommaSepEditon = "Abies alba Mill., Sp. Pl., ed. 3: 455. 1987";\r
// name = parser.parseReferencedName(strNameWith1AUthorAndCommaSepEditon, botanicCode, speciesRank);\r
public final void testParseSimpleName() {\r
\r
//Uninomials\r
- ZoologicalName milichiidae = (ZoologicalName)parser.parseSimpleName("Milichiidae", NomenclaturalCode.ICZN, null);\r
+ IZoologicalName milichiidae = (IZoologicalName)parser.parseSimpleName("Milichiidae", NomenclaturalCode.ICZN, null);\r
assertEquals("Family rank expected", Rank.FAMILY(), milichiidae.getRank());\r
BotanicalName crepidinae = (BotanicalName)parser.parseSimpleName("Crepidinae", ICNAFP, null);\r
assertEquals("Family rank expected", Rank.SUBTRIBE(), crepidinae.getRank());\r
public final void testParseSubGenericFullName() {\r
String zooSpeciesWithSubgenus = "Bacanius (Mullerister) rombophorus (Aube, 1843)";\r
//zoo as fullName\r
- ZoologicalName zooName = (ZoologicalName)parser.parseReferencedName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES());\r
+ IZoologicalName zooName = parser.parseReferencedName(zooSpeciesWithSubgenus, NomenclaturalCode.ICZN, Rank.SPECIES());\r
Assert.assertTrue(zooName.getParsingProblems().isEmpty());\r
Assert.assertEquals("Mullerister", zooName.getInfraGenericEpithet());\r
Assert.assertEquals(Integer.valueOf(1843), zooName.getOriginalPublicationYear());\r
@Test\r
public final void testParseFullNameUnicode() {\r
\r
- NonViralName<?> nameAuthor = parser.parseFullName(strNameAbiesAuthor1Unicode, null, Rank.SPECIES());\r
+ INonViralName nameAuthor = parser.parseFullName(strNameAbiesAuthor1Unicode, null, Rank.SPECIES());\r
assertEquals("Abies", nameAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameAuthor.getSpecificEpithet());\r
assertEquals("M\u00FCller", nameAuthor.getCombinationAuthorship().getNomenclaturalTitle());\r
\r
- NonViralName<?> nameBasionymAuthor = parser.parseFullName(strNameAbiesBasionymAuthor1Unicode, null, Rank.SPECIES());\r
+ INonViralName nameBasionymAuthor = parser.parseFullName(strNameAbiesBasionymAuthor1Unicode, null, Rank.SPECIES());\r
assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameBasionymAuthor.getSpecificEpithet());\r
assertEquals("D'M\u00FCller", nameBasionymAuthor.getCombinationAuthorship().getNomenclaturalTitle());\r
INomenclaturalAuthor basionymTeam = nameBasionymAuthor.getBasionymAuthorship();\r
assertEquals("Ciardelli", basionymTeam.getNomenclaturalTitle());\r
\r
- NonViralName<?> nameBasionymExAuthor = parser.parseFullName(strNameAbiesBasionymExAuthor1Unicode, null, Rank.SPECIES());\r
+ INonViralName nameBasionymExAuthor = parser.parseFullName(strNameAbiesBasionymExAuthor1Unicode, null, Rank.SPECIES());\r
assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet());\r
assertEquals("D'M\u00FCller", nameBasionymExAuthor.getExCombinationAuthorship().getNomenclaturalTitle());\r
}\r
\r
//Team\r
- NonViralName<?> nameTeam1 = parser.parseFullName(strNameTeam1);\r
+ INonViralName nameTeam1 = parser.parseFullName(strNameTeam1);\r
assertEquals( "Abies", nameTeam1.getGenusOrUninomial());\r
assertEquals( "alba", nameTeam1.getSpecificEpithet());\r
assertEquals("Mueller & L.", nameTeam1.getCombinationAuthorship().getNomenclaturalTitle());\r
assertEquals("L.", team.getTeamMembers().get(1).getNomenclaturalTitle());\r
\r
//ZooName\r
- ZoologicalName nameZoo1 = (ZoologicalName)parser.parseFullName(strNameZoo1);\r
+ IZoologicalName nameZoo1 = (IZoologicalName)parser.parseFullName(strNameZoo1);\r
assertEquals( "Abies", nameZoo1.getGenusOrUninomial());\r
assertEquals( "alba", nameZoo1.getSpecificEpithet());\r
assertEquals("Mueller & L.", nameZoo1.getCombinationAuthorship().getNomenclaturalTitle());\r
assertEquals("Mueller", teamZoo.getTeamMembers().get(0).getNomenclaturalTitle());\r
assertEquals("L.", teamZoo.getTeamMembers().get(1).getNomenclaturalTitle());\r
\r
- ZoologicalName nameZoo2 = (ZoologicalName)parser.parseFullName(strNameZoo2);\r
+ IZoologicalName nameZoo2 = (IZoologicalName)parser.parseFullName(strNameZoo2);\r
assertEquals(Integer.valueOf(2002), nameZoo2.getPublicationYear());\r
assertEquals(Integer.valueOf(1822), nameZoo2.getOriginalPublicationYear());\r
assertEquals("Mueller", nameZoo2.getBasionymAuthorship().getNomenclaturalTitle());\r
assertEquals("Ciardelli", nameZoo2.getCombinationAuthorship().getNomenclaturalTitle());\r
\r
//subsp\r
- ZoologicalName nameZoo3 = (ZoologicalName)parser.parseFullName(strNameZoo3);\r
+ IZoologicalName nameZoo3 = (IZoologicalName)parser.parseFullName(strNameZoo3);\r
assertEquals("Ciardelli", nameZoo3.getCombinationAuthorship().getNomenclaturalTitle());\r
assertFalse("Subsp. without marker should be parsable", nameZoo3.hasProblem());\r
assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo3.getRank());\r
\r
- ZoologicalName nameZoo4 = (ZoologicalName)parser.parseFullName(strNameZoo4);\r
+ IZoologicalName nameZoo4 = (IZoologicalName)parser.parseFullName(strNameZoo4);\r
assertEquals("Ciardelli", nameZoo4.getCombinationAuthorship().getNomenclaturalTitle());\r
assertFalse("Subsp. without marker should be parsable", nameZoo4.hasProblem());\r
assertEquals("Variety should be recognized", Rank.SUBSPECIES(), nameZoo4.getRank());\r
\r
- ZoologicalName nameZoo5 = (ZoologicalName)parser.parseFullName(strNameZoo5);\r
+ IZoologicalName nameZoo5 = (IZoologicalName)parser.parseFullName(strNameZoo5);\r
assertEquals("Ciardelli", nameZoo5.getCombinationAuthorship().getNomenclaturalTitle());\r
assertFalse("Subsp. without marker should be parsable", nameZoo5.hasProblem());\r
assertEquals("Variety should be recognized", Rank.VARIETY(), nameZoo5.getRank());\r
\r
\r
//empty\r
- NonViralName<?> nameEmpty = parser.parseFullName(strNameEmpty);\r
+ INonViralName nameEmpty = parser.parseFullName(strNameEmpty);\r
assertNotNull(nameEmpty);\r
assertEquals("", nameEmpty.getTitleCache());\r
\r
//null\r
- NonViralName<?> nameNull = parser.parseFullName(strNameNull);\r
+ INonViralName nameNull = parser.parseFullName(strNameNull);\r
assertNull(nameNull);\r
\r
//some authors\r
String fullNameString = "Abies alba (Greuther & L'Hiver & al. ex M\u00FCller & Schmidt)Clark ex Ciardelli";\r
- NonViralName<?> authorname = parser.parseFullName(fullNameString);\r
+ INonViralName authorname = parser.parseFullName(fullNameString);\r
assertFalse(authorname.hasProblem());\r
assertEquals("Basionym author should have 3 authors", 2, ((Team)authorname.getExBasionymAuthorship()).getTeamMembers().size());\r
Assert.assertTrue("ExbasionymAuthorship must have more members'", ((Team)authorname.getExBasionymAuthorship()).isHasMoreMembers());\r
\r
//author with 2 capitals\r
fullNameString = "Campanula rhodensis A. DC.";\r
- NonViralName<?> name = parser.parseFullName(fullNameString);\r
+ INonViralName name = parser.parseFullName(fullNameString);\r
assertFalse(name.hasProblem());\r
\r
//author with no space #5618\r
public final void testEtAl() throws StringNotParsableException {\r
//some authors\r
String fullNameString = "Abies alba Greuther, Hiver & al.";\r
- NonViralName<?> authorname = parser.parseFullName(fullNameString);\r
+ INonViralName authorname = parser.parseFullName(fullNameString);\r
assertFalse(authorname.hasProblem());\r
assertEquals("Basionym author should have 2 authors", 2, ((Team)authorname.getCombinationAuthorship()).getTeamMembers().size());\r
assertTrue("Basionym author team should have more authors", ((Team)authorname.getCombinationAuthorship()).isHasMoreMembers() );\r
\r
//et al.\r
- NonViralName<?> nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
+ INonViralName nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
parser.parseAuthors(nvn, "Eckweiler, Hand et al., 2003");\r
Team team = (Team)nvn.getCombinationAuthorship();\r
Assert.assertNotNull("Comb. author must not be null", team);\r
public final void testMultipleAuthors() {\r
//multiple authors for inReference\r
String fullTitleString = "Abies alba L. in Mill., Gregor & Behr., Sp. Pl. 173: 384. 1982.";\r
- NonViralName<?> multipleAuthorRefName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());\r
+ INonViralName multipleAuthorRefName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());\r
assertFalse(multipleAuthorRefName.hasProblem());\r
assertTrue("Combination author should be a person", multipleAuthorRefName.getCombinationAuthorship() instanceof Person);\r
assertEquals("Combination author should be L.", "L.", ((Person)multipleAuthorRefName.getCombinationAuthorship()).getNomenclaturalTitle());\r
\r
// multiple authors in Name\r
fullTitleString = "Abies alba Mill., Aber & Schwedt";\r
- NonViralName<?> multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());\r
+ INonViralName multipleAuthorName = parser.parseReferencedName(fullTitleString, NomenclaturalCode.ICNAFP, Rank.SPECIES());\r
assertFalse(multipleAuthorName.hasProblem());\r
assertTrue("Combination author should be a team", multipleAuthorName.getCombinationAuthorship() instanceof Team);\r
team = (Team)multipleAuthorName.getCombinationAuthorship();\r
assertEquals("Second team member should be Schwedt", "Schwedt", team.getTeamMembers().get(2).getTitleCache());\r
\r
//et al.\r
- NonViralName<?> nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
+ INonViralName nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
parser.parseReferencedName (nvn, "Marmota marmota Eckweiler, Hand et al., 2003", Rank.SPECIES(),true);\r
assertTrue("Combination author should be a team", nvn.getCombinationAuthorship() instanceof Team);\r
team = (Team)nvn.getCombinationAuthorship();\r
*/\r
@Test\r
public final void testHybrids() {\r
- NonViralName<?> name1;\r
+ INonViralName name1;\r
\r
\r
//Infrageneric hybrid\r
assertEquals("Infrageneric epithet must be 'Insulae'", "Insulae", name1.getInfraGenericEpithet());\r
\r
//Species hybrid\r
-// NonViralName nameTeam1 = parser.parseFullName("Aegilops \u00D7insulae-cypri H. Scholz");\r
+// INonViralName nameTeam1 = parser.parseFullName("Aegilops \u00D7insulae-cypri H. Scholz");\r
name1 = parser.parseFullName("Aegilops \u00D7insulae Scholz", botanicCode, null);\r
assertTrue("Name must have binom hybrid bit set", name1.isBinomHybrid());\r
assertFalse("Name must not have monom hybrid bit set", name1.isMonomHybrid());\r
\r
//unranked infraspecific\r
String infraspecificUnranked = "Genus species [unranked] infraspecific";\r
- NonViralName<?> name = parser.parseFullName(infraspecificUnranked);\r
+ INonViralName name = parser.parseFullName(infraspecificUnranked);\r
assertEquals( "Genus", name.getGenusOrUninomial());\r
assertEquals( "species", name.getSpecificEpithet());\r
assertEquals( "infraspecific", name.getInfraSpecificEpithet());\r
\r
//unranked infrageneric\r
String infraGenericUnranked = "Genus [unranked] Infragen";\r
- NonViralName<?> name2 = parser.parseFullName(infraGenericUnranked);\r
+ INonViralName name2 = parser.parseFullName(infraGenericUnranked);\r
assertEquals( "Genus", name2.getGenusOrUninomial());\r
assertEquals( null, name2.getSpecificEpithet());\r
assertEquals( "Infragen", name2.getInfraGenericEpithet());\r
\r
//Species hybrid\r
String hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus";\r
- NonViralName<?> name1 = parser.parseFullName(hybridCache, botanicCode, null);\r
+ INonViralName name1 = parser.parseFullName(hybridCache, botanicCode, null);\r
assertTrue("Name must have hybrid formula bit set", name1.isHybridFormula());\r
assertEquals("Name must have 2 hybrid parents", 2, name1.getHybridChildRelations().size());\r
assertEquals("Title cache must be correct", hybridCache, name1.getTitleCache());\r
//if the parser input already has hybridrelationships they need to be removed\r
//Create input\r
String hybridCache = "Abies alba "+UTF8.HYBRID+" Pinus bus";\r
- NonViralName<?> name1 = parser.parseFullName(hybridCache, botanicCode, null);\r
+ INonViralName name1 = parser.parseFullName(hybridCache, botanicCode, null);\r
assertFalse("Name must not have parsing problems", name1.hasProblem());\r
assertTrue("", name1.getHybridChildRelations().size() == 2);\r
\r
\r
private void testName_StringNomcodeRank(Method parseMethod)\r
throws InvocationTargetException, IllegalAccessException {\r
- NonViralName<?> name1 = (NonViralName<?>)parseMethod.invoke(parser, strNameAbies1, null, Rank.SPECIES());\r
+ INonViralName name1 = (INonViralName)parseMethod.invoke(parser, strNameAbies1, null, Rank.SPECIES());\r
//parser.parseFullName(strNameAbies1, null, Rank.SPECIES());\r
assertEquals("Abies", name1.getGenusOrUninomial());\r
assertEquals("alba", name1.getSpecificEpithet());\r
\r
- NonViralName<?> nameAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesAuthor1, null, Rank.SPECIES());\r
+ INonViralName nameAuthor = (INonViralName)parseMethod.invoke(parser, strNameAbiesAuthor1, null, Rank.SPECIES());\r
assertEquals("Abies", nameAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameAuthor.getSpecificEpithet());\r
assertEquals("Mueller", nameAuthor.getCombinationAuthorship().getNomenclaturalTitle());\r
\r
- NonViralName<?> nameBasionymAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesBasionymAuthor1, null, Rank.SPECIES());\r
+ INonViralName nameBasionymAuthor = (INonViralName)parseMethod.invoke(parser, strNameAbiesBasionymAuthor1, null, Rank.SPECIES());\r
assertEquals("Abies", nameBasionymAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameBasionymAuthor.getSpecificEpithet());\r
assertEquals("D'Mueller", nameBasionymAuthor.getCombinationAuthorship().getNomenclaturalTitle());\r
assertEquals("Ciardelli", nameBasionymAuthor.getBasionymAuthorship().getNomenclaturalTitle());\r
\r
- NonViralName<?> nameBasionymExAuthor = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesBasionymExAuthor1, null, Rank.SPECIES());\r
+ INonViralName nameBasionymExAuthor = (INonViralName)parseMethod.invoke(parser, strNameAbiesBasionymExAuthor1, null, Rank.SPECIES());\r
assertEquals("Abies", nameBasionymExAuthor.getGenusOrUninomial());\r
assertEquals("alba", nameBasionymExAuthor.getSpecificEpithet());\r
assertEquals("D'Mueller", nameBasionymExAuthor.getExCombinationAuthorship().getNomenclaturalTitle());\r
assertEquals("Ciardelli", nameBasionymExAuthor.getExBasionymAuthorship().getNomenclaturalTitle());\r
assertEquals("Doering", nameBasionymExAuthor.getBasionymAuthorship().getNomenclaturalTitle());\r
\r
- NonViralName<?> name2 = (NonViralName<?>)parseMethod.invoke(parser, strNameAbiesSub1, null, Rank.SPECIES());\r
+ INonViralName name2 = (INonViralName)parseMethod.invoke(parser, strNameAbiesSub1, null, Rank.SPECIES());\r
assertEquals("Abies", name2.getGenusOrUninomial());\r
assertEquals("alba", name2.getSpecificEpithet());\r
assertEquals("beta", name2.getInfraSpecificEpithet());\r
\r
// unparseable *********\r
String problemString = "sdfjlös wer eer wer";\r
- NonViralName<?> nameProblem = (NonViralName<?>)parseMethod.invoke(parser, problemString, null, Rank.SPECIES());\r
+ INonViralName nameProblem = (INonViralName)parseMethod.invoke(parser, problemString, null, Rank.SPECIES());\r
List<ParserProblem> list = nameProblem.getParsingProblems();\r
assertTrue(nameProblem.getParsingProblem()!=0);\r
assertEquals(problemString, nameProblem.getTitleCache());\r
public final void testParseNomStatus() {\r
//nom. ambig.\r
String strTestStatus = "Abies alba Mill., Sp. Pl. 4: 455. 1987, nom. ambig.";\r
- NonViralName<?> nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES());\r
+ INonViralName nameTestStatus = parser.parseReferencedName(strTestStatus, null, Rank.SPECIES());\r
assertFullRefStandard(nameTestStatus);\r
assertTrue(nameTestStatus.getStatus().size()== 1);\r
assertEquals( NomenclaturalStatusType.AMBIGUOUS(), nameTestStatus.getStatus().iterator().next().getType());\r
//null\r
String strNull = null;\r
Rank rankSpecies = Rank.SPECIES();\r
- NonViralName<?> nameNull = parser.parseReferencedName(strNull, null, rankSpecies);\r
+ INonViralName nameNull = parser.parseReferencedName(strNull, null, rankSpecies);\r
assertNull(nameNull);\r
\r
//Empty\r
String strEmpty = "";\r
- NonViralName<?> nameEmpty = parser.parseReferencedName(strEmpty, null, rankSpecies);\r
+ INonViralName nameEmpty = parser.parseReferencedName(strEmpty, null, rankSpecies);\r
assertFalse(nameEmpty.hasProblem());\r
assertEquals(strEmpty, nameEmpty.getFullTitleCache());\r
assertNull(nameEmpty.getNomenclaturalMicroReference());\r
\r
//Whitespaces\r
String strFullWhiteSpcaceAndDot = "Abies alba Mill., Sp. Pl. 4: 455 . 1987 .";\r
- NonViralName<?> namefullWhiteSpcaceAndDot = parser.parseReferencedName(strFullWhiteSpcaceAndDot, null, rankSpecies);\r
+ INonViralName namefullWhiteSpcaceAndDot = parser.parseReferencedName(strFullWhiteSpcaceAndDot, null, rankSpecies);\r
assertFullRefStandard(namefullWhiteSpcaceAndDot);\r
assertTrue(((Reference)namefullWhiteSpcaceAndDot.getNomenclaturalReference()).getType().equals(eu.etaxonomy.cdm.model.reference.ReferenceType.Book));\r
assertEquals( "Abies alba Mill., Sp. Pl. 4: 455. 1987", namefullWhiteSpcaceAndDot.getFullTitleCache());\r
\r
//Book\r
String fullReference = "Abies alba Mill., Sp. Pl. 4: 455. 1987";\r
- NonViralName<?> name1 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName name1 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFullRefStandard(name1);\r
assertTrue(((Reference)name1.getNomenclaturalReference()).getType().equals(eu.etaxonomy.cdm.model.reference.ReferenceType.Book));\r
assertEquals(fullReference, name1.getFullTitleCache());\r
\r
//Book Section\r
fullReference = "Abies alba Mill. in Otto, Sp. Pl. 4(6): 455. 1987";\r
- NonViralName<?> name2 = parser.parseReferencedName(fullReference + ".", null, rankSpecies);\r
+ INonViralName name2 = parser.parseReferencedName(fullReference + ".", null, rankSpecies);\r
assertFullRefNameStandard(name2);\r
assertEquals(fullReference, name2.getFullTitleCache());\r
assertFalse(name2.hasProblem());\r
\r
//Article\r
fullReference = "Abies alba Mill. in Sp. Pl. 4(6): 455. 1987";\r
- NonViralName<?> name3 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName name3 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFullRefNameStandard(name3);\r
name3.setTitleCache(null);\r
assertEquals(fullReference, name3.getFullTitleCache());\r
\r
//Article with volume range\r
fullReference = "Abies alba Mill. in Sp. Pl. 4(1-2): 455. 1987";\r
- NonViralName<?> name3a = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName name3a = parser.parseReferencedName(fullReference, null, rankSpecies);\r
name3a.setTitleCache(null);\r
assertEquals(fullReference, name3a.getFullTitleCache());\r
assertFalse(name3a.hasProblem());\r
String fullReferenceWithoutYear = "Abies alba Mill. in " + journalTitle + " 4(6): 455.";\r
fullReference = fullReferenceWithoutYear + yearPart;\r
String fullReferenceWithEnd = fullReference + ".";\r
- NonViralName<?> name4 = parser.parseReferencedName(fullReferenceWithEnd, null, rankSpecies);\r
+ INonViralName name4 = parser.parseReferencedName(fullReferenceWithEnd, null, rankSpecies);\r
assertFalse(name4.hasProblem());\r
assertFullRefNameStandard(name4);\r
assertEquals(fullReferenceWithoutYear + " " + parsedYear, name4.getFullTitleCache());\r
\r
//Zoo name\r
String strNotParsableZoo = "Abies alba M., 1923, Sp. P. xxwer4352, nom. inval.";\r
- ZoologicalName nameZooRefNotParsabel = (ZoologicalName)parser.parseReferencedName(strNotParsableZoo, null, null);\r
+ IZoologicalName nameZooRefNotParsabel = parser.parseReferencedName(strNotParsableZoo, null, null);\r
assertTrue(nameZooRefNotParsabel.hasProblem());\r
List<ParserProblem> list = nameZooRefNotParsabel.getParsingProblems();\r
assertTrue("List must contain detail and year warning ", list.contains(ParserProblem.CheckDetailOrYear));\r
assertEquals(1, nameZooRefNotParsabel.getStatus().size());\r
\r
String strZooNameSineYear = "Homo sapiens L., 1758, Sp. An. 3: 345";\r
- ZoologicalName nameZooNameSineYear = (ZoologicalName)parser.parseReferencedName(strZooNameSineYear);\r
+ IZoologicalName nameZooNameSineYear = parser.parseReferencedName(strZooNameSineYear);\r
assertFalse(nameZooNameSineYear.hasProblem());\r
assertEquals("Name without reference year must have year", (Integer)1758, nameZooNameSineYear.getPublicationYear());\r
assertEquals("Name without reference year must have year", "1758", nameZooNameSineYear.getNomenclaturalReference().getYear());\r
\r
String strZooNameNewCombination = "Homo sapiens (L., 1758) Mill., 1830, Sp. An. 3: 345";\r
- ZoologicalName nameZooNameNewCombination = (ZoologicalName)parser.parseReferencedName(strZooNameNewCombination);\r
+ IZoologicalName nameZooNameNewCombination = parser.parseReferencedName(strZooNameNewCombination);\r
assertTrue(nameZooNameNewCombination.hasProblem());\r
list = nameZooNameNewCombination.getParsingProblems();\r
assertTrue("List must contain new combination has publication warning ", list.contains(ParserProblem.NewCombinationHasPublication));\r
\r
//Special MicroRefs\r
String strSpecDetail1 = "Abies alba Mill. in Sp. Pl. 4(6): [455]. 1987";\r
- NonViralName<?> nameSpecDet1 = parser.parseReferencedName(strSpecDetail1 + ".", null, rankSpecies);\r
+ INonViralName nameSpecDet1 = parser.parseReferencedName(strSpecDetail1 + ".", null, rankSpecies);\r
assertFalse(nameSpecDet1.hasProblem());\r
assertEquals(strSpecDetail1, nameSpecDet1.getFullTitleCache());\r
assertEquals("[455]", nameSpecDet1.getNomenclaturalMicroReference());\r
\r
//Special MicroRefs\r
String strSpecDetail2 = "Abies alba Mill. in Sp. Pl. 4(6): couv. 2. 1987";\r
- NonViralName<?> nameSpecDet2 = parser.parseReferencedName(strSpecDetail2 + ".", null, rankSpecies);\r
+ INonViralName nameSpecDet2 = parser.parseReferencedName(strSpecDetail2 + ".", null, rankSpecies);\r
assertFalse(nameSpecDet2.hasProblem());\r
assertEquals(strSpecDetail2, nameSpecDet2.getFullTitleCache());\r
assertEquals("couv. 2", nameSpecDet2.getNomenclaturalMicroReference());\r
\r
//Special MicroRefs\r
String strSpecDetail3 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455. 1987";\r
- NonViralName<?> nameSpecDet3 = parser.parseReferencedName(strSpecDetail3 + ".", null, rankSpecies);\r
+ INonViralName nameSpecDet3 = parser.parseReferencedName(strSpecDetail3 + ".", null, rankSpecies);\r
assertFalse(nameSpecDet3.hasProblem());\r
assertEquals(strSpecDetail3, nameSpecDet3.getFullTitleCache());\r
assertEquals("fig. 455", nameSpecDet3.getNomenclaturalMicroReference());\r
//Special MicroRefs\r
String strSpecDetail4 = "Abies alba Mill. in Sp. Pl. 4(6): fig. 455-567. 1987";\r
fullReference = strSpecDetail4 + ".";\r
- NonViralName<?> nameSpecDet4 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName nameSpecDet4 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFalse(nameSpecDet4.hasProblem());\r
assertEquals(strSpecDetail4, nameSpecDet4.getFullTitleCache());\r
assertEquals("fig. 455-567", nameSpecDet4.getNomenclaturalMicroReference());\r
//Special MicroRefs\r
String strSpecDetail5 = "Abies alba Mill. in Sp. Pl. 4(6): Gard n\u00B0 4. 1987";\r
fullReference = strSpecDetail5 + ".";\r
- NonViralName<?> nameSpecDet5 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName nameSpecDet5 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFalse(nameSpecDet5.hasProblem());\r
assertEquals(strSpecDetail5, nameSpecDet5.getFullTitleCache());\r
assertEquals("Gard n\u00B0 4", nameSpecDet5.getNomenclaturalMicroReference());\r
//Special MicroRefs\r
String strSpecDetail6 = "Abies alba Mill. in Sp. Pl. 4(6): 455a. 1987";\r
fullReference = strSpecDetail6 + ".";\r
- NonViralName<?> nameSpecDet6 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName nameSpecDet6 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFalse(nameSpecDet6.hasProblem());\r
assertEquals(strSpecDetail6, nameSpecDet6.getFullTitleCache());\r
assertEquals("455a", nameSpecDet6.getNomenclaturalMicroReference());\r
//Special MicroRefs\r
String strSpecDetail7 = "Abies alba Mill. in Sp. Pl. 4(6): pp.455-457. 1987";\r
fullReference = strSpecDetail7 + ".";\r
- NonViralName<?> nameSpecDet7 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
+ INonViralName nameSpecDet7 = parser.parseReferencedName(fullReference, null, rankSpecies);\r
assertFalse(nameSpecDet7.hasProblem());\r
assertEquals(strSpecDetail7, nameSpecDet7.getFullTitleCache());\r
assertEquals("pp.455-457", nameSpecDet7.getNomenclaturalMicroReference());\r
\r
//Special MicroRefs\r
String strSpecDetail8 = "Abies alba Mill. in Sp. Pl. 4(6): ppp.455-457. 1987";\r
- NonViralName<?> nameSpecDet8 = parser.parseReferencedName(strSpecDetail8, null, rankSpecies);\r
+ INonViralName nameSpecDet8 = parser.parseReferencedName(strSpecDetail8, null, rankSpecies);\r
assertTrue(nameSpecDet8.hasProblem());\r
assertEquals(20, nameSpecDet8.getProblemStarts()); //TODO better start behind :\r
assertEquals(51, nameSpecDet8.getProblemEnds()); //TODO better stop after -457\r
\r
//Special MicroRefs\r
String strSpecDetail9 = "Abies alba Mill. in Sp. Pl. 4(6): pp. 455 - 457. 1987";\r
- NonViralName<?> nameSpecDet9 = parser.parseReferencedName(strSpecDetail9, null, rankSpecies);\r
+ INonViralName nameSpecDet9 = parser.parseReferencedName(strSpecDetail9, null, rankSpecies);\r
assertFalse(nameSpecDet9.hasProblem());\r
assertEquals(strSpecDetail9, nameSpecDet9.getFullTitleCache());\r
assertEquals("pp. 455 - 457", nameSpecDet9.getNomenclaturalMicroReference());\r
\r
//Special MicroRefs\r
String strSpecDetail10 = "Abies alba Mill. in Sp. Pl. 4(6): p 455. 1987";\r
- NonViralName<?> nameSpecDet10 = parser.parseReferencedName(strSpecDetail10, null, rankSpecies);\r
+ INonViralName nameSpecDet10 = parser.parseReferencedName(strSpecDetail10, null, rankSpecies);\r
assertFalse(nameSpecDet10.hasProblem());\r
assertEquals(strSpecDetail10, nameSpecDet10.getFullTitleCache());\r
assertEquals("p 455", nameSpecDet10.getNomenclaturalMicroReference());\r
\r
//Special MicroRefs\r
String strSpecDetail11 = "Abies alba Mill. in Sp. Pl. 4(6): p. 455 - 457. 1987";\r
- NonViralName<?> nameSpecDet11 = parser.parseReferencedName(strSpecDetail11, null, rankSpecies);\r
+ INonViralName nameSpecDet11 = parser.parseReferencedName(strSpecDetail11, null, rankSpecies);\r
assertTrue(nameSpecDet11.hasProblem());\r
list = nameSpecDet11.getParsingProblems();\r
assertTrue("Problem is Detail. Must be pp.", list.contains(ParserProblem.CheckDetailOrYear));\r
\r
//no volume, no edition\r
String strNoVolume = "Abies alba Mill., Sp. Pl.: 455. 1987";\r
- NonViralName<?> nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies);\r
+ INonViralName nameNoVolume = parser.parseReferencedName(strNoVolume, null, rankSpecies);\r
assertFalse(nameNoVolume.hasProblem());\r
assertEquals(strNoVolume, nameNoVolume.getFullTitleCache());\r
assertEquals(null, ((IVolumeReference)(nameNoVolume.getNomenclaturalReference())).getVolume());\r
assertEquals("3", ((IBook)(nameNoVolume.getNomenclaturalReference())).getEdition());\r
\r
String strUnparsableInRef = "Abies alba Mill. in -er46: 455. 1987";\r
- NonViralName<?> nameUnparsableInRef = parser.parseReferencedName(strUnparsableInRef, null, rankSpecies);\r
+ INonViralName nameUnparsableInRef = parser.parseReferencedName(strUnparsableInRef, null, rankSpecies);\r
assertTrue(nameUnparsableInRef.hasProblem());\r
list = nameUnparsableInRef.getParsingProblems();\r
assertTrue("Unparsable title", list.contains(ParserProblem.UnparsableReferenceTitle));\r
\r
//volume, edition\r
String strNoSeparator = "Abies alba Mill. Sp. Pl. ed. 3, 4(5): 455. 1987";\r
- NonViralName<?> nameNoSeparator = parser.parseReferencedName(strNoSeparator, ICNAFP, rankSpecies);\r
+ INonViralName nameNoSeparator = parser.parseReferencedName(strNoSeparator, ICNAFP, rankSpecies);\r
assertTrue(nameNoSeparator.hasProblem());\r
list = nameNoSeparator.getParsingProblems();\r
assertTrue("Problem is missing name-reference separator", list.contains(ParserProblem.NameReferenceSeparation));\r
assertEquals(47, nameNoSeparator.getProblemEnds()); //TODO better stop before :\r
\r
String strUnparsableInRef2 = "Hieracium pepsicum L., My Bookkkk 1. 1903";\r
- NonViralName<?> nameUnparsableInRef2 = parser.parseReferencedName(strUnparsableInRef2, null, rankSpecies);\r
+ INonViralName nameUnparsableInRef2 = parser.parseReferencedName(strUnparsableInRef2, null, rankSpecies);\r
assertTrue(nameUnparsableInRef2.hasProblem());\r
list = nameUnparsableInRef2.getParsingProblems();\r
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));\r
\r
\r
String strUnparsableInRef3 = "Hieracium pespcim N., My Bookkkk 1. 1902";\r
- NonViralName<?> nameUnparsableInRef3 = parser.parseReferencedName(strUnparsableInRef3, null, null);\r
+ INonViralName nameUnparsableInRef3 = parser.parseReferencedName(strUnparsableInRef3, null, null);\r
assertTrue(nameUnparsableInRef3.hasProblem());\r
list = nameUnparsableInRef3.getParsingProblems();\r
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));\r
assertEquals(40, nameUnparsableInRef3.getProblemEnds());\r
\r
String strUnparsableInRef4 = "Hieracium pepsicum (Hsllreterto) L., My Bookkkk 1. 1903";\r
- NonViralName<?> nameUnparsableInRef4 = parser.parseReferencedName(strUnparsableInRef4, null, null);\r
+ INonViralName nameUnparsableInRef4 = parser.parseReferencedName(strUnparsableInRef4, null, null);\r
assertTrue(nameUnparsableInRef4.hasProblem());\r
list = nameUnparsableInRef4.getParsingProblems();\r
assertTrue("Problem detail", list.contains(ParserProblem.CheckDetailOrYear));\r
assertEquals(55, nameUnparsableInRef4.getProblemEnds());\r
\r
String strSameName = "Hieracium pepcum (Hsllreterto) L., My Bokkk 1. 1903";\r
- NonViralName<?> nameSameName = nameUnparsableInRef4;\r
+ INonViralName nameSameName = nameUnparsableInRef4;\r
parser.parseReferencedName(nameSameName, strSameName, null, true);\r
assertTrue(nameSameName.hasProblem());\r
list = nameSameName.getParsingProblems();\r
assertEquals(51, nameSameName.getProblemEnds());\r
\r
String strGenusUnparse = "Hieracium L., jlklk";\r
- NonViralName<?> nameGenusUnparse =\r
+ INonViralName nameGenusUnparse =\r
parser.parseReferencedName(strGenusUnparse, null, null);\r
assertTrue(nameGenusUnparse.hasProblem());\r
list = nameGenusUnparse.getParsingProblems();\r
assertEquals(19, nameGenusUnparse.getProblemEnds());\r
\r
String strGenusUnparse2 = "Hieracium L., Per Luigi: 44. 1987";\r
- NonViralName<?> nameGenusUnparse2 =\r
+ INonViralName nameGenusUnparse2 =\r
parser.parseReferencedName(strGenusUnparse2, null, Rank.FAMILY());\r
assertFalse(nameGenusUnparse2.hasProblem());\r
assertEquals(strGenusUnparse2, nameGenusUnparse2.getFullTitleCache());\r
\r
String strBookSection2 = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz, ed. 2, 2: 288. 1905-1907";\r
String strBookSection2NoComma = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905-1907";\r
- NonViralName<?> nameBookSection2 =\r
+ INonViralName nameBookSection2 =\r
parser.parseReferencedName(strBookSection2, null, null);\r
assertFalse(nameBookSection2.hasProblem());\r
nameBookSection2.setFullTitleCache(null, false);\r
\r
\r
String strBookSection = "Hieracium vulgatum subsp. acuminatum (Jord.) Zahn in Schinz & Keller, Fl. Schweiz ed. 2, 2: 288. 1905";\r
- NonViralName<?> nameBookSection =\r
+ INonViralName nameBookSection =\r
parser.parseReferencedName(strBookSection, null, null);\r
assertFalse(nameBookSection.hasProblem());\r
assertEquals(strBookSection.replace(" ed.", ", ed."), nameBookSection.getFullTitleCache());\r
assertEquals("1905", ((IBookSection)nameBookSection.getNomenclaturalReference()).getDatePublished().getYear());\r
\r
String strXXXs = "Abies alba, Soer der 1987";\r
- NonViralName<?> problemName = parser.parseReferencedName(strXXXs, null, null);\r
+ INonViralName problemName = parser.parseReferencedName(strXXXs, null, null);\r
assertTrue(problemName.hasProblem());\r
list = problemName.getParsingProblems();\r
assertTrue("Problem must be name-reference separation", list.contains(ParserProblem.NameReferenceSeparation));\r
* @return\r
*/\r
private List<ParserProblem> getProblems(String string, NomenclaturalCode code) {\r
- List<ParserProblem> result;\r
- result = parser.parseReferencedName(string, code, null).getParsingProblems();\r
+ List<ParserProblem> result = parser.parseReferencedName(string, code, null).getParsingProblems();\r
return result;\r
}\r
\r
private boolean isParsable(String string, NomenclaturalCode code){\r
- NonViralName<?> name = parser.parseReferencedName(string, code, null);\r
+ INonViralName name = parser.parseReferencedName(string, code, null);\r
return ! name.hasProblem();\r
}\r
\r
- private void assertFullRefNameStandard(NonViralName<?> name){\r
+ private void assertFullRefNameStandard(INonViralName name){\r
assertEquals("Abies", name.getGenusOrUninomial());\r
assertEquals("alba", name.getSpecificEpithet());\r
assertEquals("Mill.", name.getAuthorshipCache());\r
assertNotNull(name.getNomenclaturalReference());\r
}\r
\r
- private void assertFullRefStandard(NonViralName<?> name){\r
+ private void assertFullRefStandard(INonViralName name){\r
assertEquals("Abies", name.getGenusOrUninomial());\r
assertEquals("alba", name.getSpecificEpithet());\r
assertEquals("Mill.", name.getAuthorshipCache());\r
\r
String irinaExample = "Milichiidae Sharp, 1899, Insects. Part II. Hymenopteracontinued (Tubulifera and Aculeata), Coleoptera, Strepsiptera, Lepidoptera, Diptera, Aphaniptera, Thysanoptera, Hemiptera, Anoplura 6: 504. 1899";\r
// irinaExample = "Milichiidae Sharp, 1899, Insects. Part II. Uiuis Iuiui Hymenopteracontinued (Tubulifera and Aculeata), Coleoptera, Strepsiptera, Lepidoptera, Diptera, Aphaniptera, Thysanoptera, Hemiptera, Anoplura 6: 504. 1899";\r
- NonViralName<?> nvn = this.parser.parseReferencedName(irinaExample, NomenclaturalCode.ICZN, null);\r
+ INonViralName nvn = this.parser.parseReferencedName(irinaExample, NomenclaturalCode.ICZN, null);\r
int parsingProblem = nvn.getParsingProblem();\r
Assert.assertEquals("Name should have only rank warning", 1, parsingProblem);\r
Assert.assertEquals("Titlecache", "Milichiidae Sharp, 1899", nvn.getTitleCache());\r
*/\r
@Test\r
public final void testParseAuthorsTaxonNameString() throws StringNotParsableException {\r
- NonViralName<?> nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
+ INonViralName nvn = TaxonNameFactory.NewZoologicalInstance(null);\r
parser.parseAuthors(nvn, "Eckweiler & ten Hagen, 2003");\r
Team team = (Team)nvn.getCombinationAuthorship();\r
Assert.assertNotNull("Comb. author must not be null", team);\r
Assert.assertEquals("Second member must be 'ten Hagen'", "ten Hagen", team.getTeamMembers().get(1).getTitleCache());\r
\r
//Crosson du Cormier, 1964\r
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(null);\r
+ IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(null);\r
parser.parseAuthors(zooName, "Crosson du Cormier, 1964");\r
Person person = (Person)zooName.getCombinationAuthorship();\r
Assert.assertNotNull("Comb. author must not be null", person);\r
//this test does not really test problematic cases where sect.idInVoc = "sect." instead of "sect.(bot.)"\r
//however, by changing the csv file entry to sect. just for testing it can be used as a functional test\r
String sectionNameStr = "Taraxacum sect. Testtaxa M\u00fcller, Incredible Taxa: 12. 2016";\r
- NonViralName<?> sectionName = parser.parseReferencedName(sectionNameStr, NomenclaturalCode.ICNAFP, null);\r
+ INonViralName sectionName = parser.parseReferencedName(sectionNameStr, NomenclaturalCode.ICNAFP, null);\r
int parsingProblem = sectionName.getParsingProblem();\r
Assert.assertEquals("Problem should be 0", 0, parsingProblem);\r
Rank rank = sectionName.getRank();\r
public final void testLongRunningParsingCapitals(){\r
DateTime start = DateTime.now();\r
String nameStr = "Nazeris fujianensis JIAYAO HU, LIZHEN LI, MEIJUN ZHAO,2010"; //name from CoL that created problems\r
- NonViralName<?> name = parser.parseReferencedName(nameStr, NomenclaturalCode.ICZN, null);\r
+ INonViralName name = parser.parseReferencedName(nameStr, NomenclaturalCode.ICZN, null);\r
DateTime end = DateTime.now();\r
Duration duration = new Duration(start, end);\r
long seconds = duration.getStandardSeconds();\r
//name only\r
String nameStr = "Dictyocoela berillonum R.S. Terry, J.E. Sm., R.G. Sharpe, T. Rigaud, D.T.J. Littlewood, J.E. Ironside, D. Rollinson & D. Bou";\r
DateTime start = DateTime.now();\r
- NonViralName<?> name = parser.parseReferencedName(nameStr, NomenclaturalCode.ICNAFP, null);\r
+ INonViralName name = parser.parseReferencedName(nameStr, NomenclaturalCode.ICNAFP, null);\r
DateTime end = DateTime.now();\r
Duration duration = new Duration(start, end);\r
long seconds = duration.getStandardSeconds();\r
@Test\r
public final void testSpecificAuthors(){\r
//McVaugh\r
- NonViralName<?> name = parser.parseFullName("Psidium longipes var. orbiculare (O.Berg) McVaugh");\r
+ INonViralName name = parser.parseFullName("Psidium longipes var. orbiculare (O.Berg) McVaugh");\r
Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());\r
TeamOrPersonBase<?> combinationAuthor = name.getCombinationAuthorship();\r
assertEquals( "McVaugh", combinationAuthor.getNomenclaturalTitle());\r
@Test\r
public final void testExistingProblems(){\r
//Canabio, issue with space\r
- NonViralName<?> name = parser.parseReferencedName("Machaonia erythrocarpa var. hondurensis (Standl.) Borhidi"\r
+ INonViralName name = parser.parseReferencedName("Machaonia erythrocarpa var. hondurensis (Standl.) Borhidi"\r
+ " in Acta Bot. Hung. 46 (1-2): 30. 2004");\r
Assert.assertFalse("Name should be parsable", name.isProtectedTitleCache());\r
TeamOrPersonBase<?> combinationAuthor = name.getCombinationAuthorship();\r
\r
import org.apache.log4j.Logger;\r
\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
+import eu.etaxonomy.cdm.model.name.IBotanicalName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;\r
\r
private boolean test(){\r
INonViralNameParser parser = NonViralNameParserImpl.NewInstance();\r
- BotanicalName nameToBeFilled = TaxonNameFactory.NewBotanicalInstance(null);\r
+ IBotanicalName nameToBeFilled = TaxonNameFactory.NewBotanicalInstance(null);\r
String fullReference = "Abies alba Mill., Sp. Pl. 4: 455. 1987.";\r
boolean makeEmpty = false;\r
Rank rank = null;\r
import eu.etaxonomy.cdm.model.media.MediaRepresentation;\r
import eu.etaxonomy.cdm.model.media.MediaRepresentationPart;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.occurrence.Collection;\r
import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;\r
import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;\r
logger.info("Create test taxon ...");\r
Reference sec = ReferenceFactory.newDatabase();\r
String fullNameString = "Acanthostyles saucechicoensis (Hieron.) R.M. King & H. Rob.";\r
- BotanicalName botanicalName = (BotanicalName)NonViralNameParserImpl.NewInstance().parseFullName(fullNameString);\r
+ TaxonNameBase<?,?> botanicalName = (BotanicalName)NonViralNameParserImpl.NewInstance().parseFullName(fullNameString);\r
Taxon taxon = Taxon.NewInstance(botanicalName, sec);\r
\r
Collection collection = Collection.NewInstance();\r
import org.junit.Test;\r
\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.strategy.parser.INonViralNameParser;\r
import eu.etaxonomy.cdm.strategy.parser.NonViralNameParserImpl;\r
\r
\r
private int parseIt(String fullRef1){\r
- NonViralName<?> nvName = TaxonNameFactory.NewZoologicalInstance(null);\r
+ INonViralName nvName = TaxonNameFactory.NewZoologicalInstance(null);\r
NonViralNameParserImpl parser = new NonViralNameParserImpl();\r
\r
//parser.parseFullName(strNameAbiesBasionymAuthorUe, null);\r
import eu.etaxonomy.cdm.model.agent.Person;
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.validation.constraint.BasionymsMustShareEpithetsAndAuthorsValidator;
Reference nomRef = ReferenceFactory.newBook();
Reference nomRef2 = ReferenceFactory.newBook();
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
zooName.setGenusOrUninomial("Aus");
zooName.setSpecificEpithet("aus");
zooName.setBasionymAuthorship(author1);
zooName.setNomenclaturalReference(nomRef);
- ZoologicalName originalCombination = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ IZoologicalName originalCombination = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
originalCombination.setGenusOrUninomial("Aus");
originalCombination.setSpecificEpithet("aus");
originalCombination.setCombinationAuthorship(author1);
originalCombination.setNomenclaturalReference(nomRef);
- zooName.addBasionym(originalCombination);
+ zooName.addBasionym(TaxonNameBase.castAndDeproxy(originalCombination));
Assert.assertEquals(1, zooName.getNameRelations().size());
\r
import eu.etaxonomy.cdm.model.common.DefaultTermInitializer;\r
import eu.etaxonomy.cdm.model.name.BotanicalName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
-import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;\r
@Test\r
public void testZooName() {\r
\r
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());\r
+ IZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());\r
\r
zooName.setNomenclaturalReference(null);\r
zooName.setPublicationYear(1788);\r
import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment;
import eu.etaxonomy.cdm.model.molecular.SingleReadAlignment.Shift;
import eu.etaxonomy.cdm.model.name.BacterialName;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.CultivarPlantName;
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.name.ViralName;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.occurrence.Collection;
import eu.etaxonomy.cdm.model.occurrence.DerivationEvent;
import eu.etaxonomy.cdm.model.occurrence.DerivationEventType;
mediaSpecimen.setAccessionNumber("accessionNumber");
// mediaSpecimen.setCollectorsNumber("collectorsNumber");
mediaSpecimen.setBarcode("barcode");
- BotanicalName storedUnder = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> storedUnder = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
storedUnder.setTitleCache("Stored under", true);
mediaSpecimen.setStoredUnder(storedUnder);
mediaSpecimen.setExsiccatum("exsiccatum");
botName.setExBasionymAuthorship(exBasionymAuthorship);
handleIdentifiableEntity(botName);
handleAnnotatableEntity(botName.getHomotypicalGroup());
- BotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
HybridRelationship hybridRel = botName2.addHybridChild(botName, HybridRelationshipType.FIRST_PARENT(), "Rule 1.2.3");
hybridRel.setCitation(ReferenceFactory.newBook());
hybridRel.setCitationMicroReference("p. 123");
handleAnnotatableEntity(hybridRel);
- ZoologicalName zooName = TaxonNameFactory.NewZoologicalInstance(Rank.GENUS());
+ TaxonNameBase<?,?> zooName = TaxonNameFactory.NewZoologicalInstance(Rank.GENUS());
zooName.setBreed("breed");
zooName.setPublicationYear(1922);
zooName.setOriginalPublicationYear(1987);
handleIdentifiableEntity(zooName);
//TypeDesignation
- ZoologicalName speciesZooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> speciesZooName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
NameTypeDesignation nameDesig = zooName.addNameTypeDesignation(speciesZooName, getReference(), "111", "original name",
NameTypeDesignationStatus.AUTOMATIC(), true, true, true, true);
handleAnnotatableEntity(nameDesig);
import org.springframework.stereotype.Repository;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
-import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.RelationshipBase;
import eu.etaxonomy.cdm.model.name.BacterialName;
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
+import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NonViralName;
}
@Override
- public int countHybridNames(NonViralName name, HybridRelationshipType type) {
+ public int countHybridNames(INonViralName name, HybridRelationshipType type) {
AuditEvent auditEvent = getAuditEventFromContext();
if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
Query query = null;
}
@Override
- public List<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
+ public List<HybridRelationship> getHybridNames(INonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
AuditEvent auditEvent = getAuditEventFromContext();
if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {
Criteria criteria = getSession().createCriteria(HybridRelationship.class);
@Override
- public ZoologicalName findZoologicalNameByUUID(UUID uuid){
+ public IZoologicalName findZoologicalNameByUUID(UUID uuid){
Criteria criteria = getSession().createCriteria(type);
if (uuid != null) {
criteria.add(Restrictions.eq("uuid", uuid));
return null;
}
+ @SuppressWarnings("unchecked")
List<? extends TaxonNameBase<?,?>> results = criteria.list();
if (results.size() == 1) {
defaultBeanInitializer.initializeAll(results, null);
TaxonNameBase<?, ?> taxonName = results.iterator().next();
if (taxonName.isInstanceOf(ZoologicalName.class)) {
- ZoologicalName zoologicalName = CdmBase.deproxy(taxonName, ZoologicalName.class);
+ IZoologicalName zoologicalName = taxonName;
return zoologicalName;
} else {
logger.warn("This UUID (" + uuid + ") does not belong to a ZoologicalName. It belongs to: " + taxonName.getUuid() + " (" + taxonName.getTitleCache() + ")");
Query query=getSession().createQuery("select tmb2 from ZoologicalName tmb, ZoologicalName tmb2 fetch all properties where tmb.id != tmb2.id and tmb.nameCache = tmb2.nameCache");
+ @SuppressWarnings("unchecked")
List<TaxonNameBase> zooNames = query.list();
TaxonNameComparator taxComp = new TaxonNameComparator();
Collections.sort(zooNames, taxComp);
- for (TaxonNameBase taxonNameBase: zooNames){
+ for (TaxonNameBase<?,?> taxonNameBase: zooNames){
defaultBeanInitializer.initialize(taxonNameBase, propertyPaths);
}
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
// to avoid too much casting
if(bean instanceof NonViralName){
// ---> NonViralName
- NonViralName<?> n = (NonViralName<?>)bean;
+ INonViralName n = (INonViralName)bean;
if(!n.isProtectedFullTitleCache()) {
n.getFullTitleCache();
} else if(!bean.isProtectedTitleCache()){
import eu.etaxonomy.cdm.model.common.RelationshipBase;\r
import eu.etaxonomy.cdm.model.name.HybridRelationship;\r
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;\r
+import eu.etaxonomy.cdm.model.name.INonViralName;\r
+import eu.etaxonomy.cdm.model.name.IZoologicalName;\r
import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.NameRelationshipType;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;\r
import eu.etaxonomy.cdm.model.name.TypeDesignationStatusBase;\r
-import eu.etaxonomy.cdm.model.name.ZoologicalName;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
* the hybrid relationship type (or null to return all hybrid)\r
* @return a count of HybridRelationship instances\r
*/\r
- public int countHybridNames(NonViralName name, HybridRelationshipType type);\r
+ public int countHybridNames(INonViralName name, HybridRelationshipType type);\r
\r
/**\r
* Return a List of hybrids related to this name, optionally filtered by\r
* set (0 - based)\r
* @return a List of HybridRelationship instances\r
*/\r
- public List<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);\r
+ public List<HybridRelationship> getHybridNames(INonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);\r
\r
/**\r
* Return a count of types related to this name, optionally filtered by type\r
*/\r
public long countByName(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria);\r
\r
- public ZoologicalName findZoologicalNameByUUID(UUID uuid);\r
+ public IZoologicalName findZoologicalNameByUUID(UUID uuid);\r
\r
List<HashMap<String, String>> getNameRecords();\r
}\r
import eu.etaxonomy.cdm.model.common.User;
import eu.etaxonomy.cdm.model.common.VersionableEntity;
import eu.etaxonomy.cdm.model.molecular.Amplification;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
IdentifiableEntity<?> identifiableEntity = (IdentifiableEntity)entity;
if(NonViralName.class.isAssignableFrom(entityClazz)) {
//non-viral-name caches
- NonViralName<?> nonViralName = (NonViralName<?>)entity;
+ INonViralName nonViralName = (INonViralName)entity;
nonViralName.getAuthorshipCache();
nonViralName.getNameCache();
nonViralName.getTitleCache();
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
@DataSet(loadStrategy=CleanSweepInsertLoadStrategy.class, value="/eu/etaxonomy/cdm/database/ClearDB_with_Terms_DataSet.xml"),
@DataSet("/eu/etaxonomy/cdm/database/TermsDataSet-with_auditing_info.xml")})
public void testGetReferencingObjectsCdmBase() {
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setTitleCache("A name", true);
Reference ref1 = ReferenceFactory.newArticle();
Taxon taxon = Taxon.NewInstance(name, ref1);
// @Ignore
public void testMergeCdmBaseReferenceAndIdentifiable() throws MergeException {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
- BotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("BotanicalName2", true);
- ZoologicalName zooName1 = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> zooName1 = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
name1.setTitleCache("ZoologicalName1", true);
Reference article1 = ReferenceFactory.newArticle();
@Test
// @Ignore
public void testMergeTaxonNameAndTaxon() throws MergeException {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
- BotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("BotanicalName2", true);
- BotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name3.setTitleCache("BotanicalName3", true);
Reference database = ReferenceFactory.newDatabase();
@Test
public void testMergeAuthors() throws MergeException {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
- BotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("BotanicalName2", true);
IBook book1 = ReferenceFactory.newBook();
@Test
public void testReallocatePersonTeam() throws MergeException {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("BotanicalName1", true);
IBook book1 = ReferenceFactory.newBook();
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.persistence.dao.name.IHomotypicalGroupDao;
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
@Test
public void testCountNamesByExample() {
- ZoologicalName zoologicalName = TaxonNameFactory.NewZoologicalInstance(Rank.GENUS());
+ TaxonNameBase<?,?> zoologicalName = TaxonNameFactory.NewZoologicalInstance(Rank.GENUS());
zoologicalName.setGenusOrUninomial("Atropos");
Set<String> includedProperties = new HashSet<String>();
includedProperties.add("genusOrUninomial");
includedProperties.add("specificEpithet");
includedProperties.add("infraSpecificEpithet");
includedProperties.add("rank");
- int count = taxonNameDao.count(zoologicalName,includedProperties);
+ int count = taxonNameDao.count(zoologicalName, includedProperties);
assertEquals("countNames should return 3",3,count);
}
import java.util.List;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
import eu.etaxonomy.cdm.strategy.cache.TaggedText;
import eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy;
-public class TestingBotanicalNameCacheStrategy implements INonViralNameCacheStrategy<BotanicalName> {
+public class TestingBotanicalNameCacheStrategy implements INonViralNameCacheStrategy<IBotanicalName> {
@Override
- public String getAuthorshipCache(BotanicalName nonViralName) {
+ public String getAuthorshipCache(IBotanicalName nonViralName) {
return "test.botanical.authorshipCache"+ nonViralName.getId();
}
@Override
- public String getLastEpithet(BotanicalName taxonNameBase) {
+ public String getLastEpithet(IBotanicalName taxonNameBase) {
return "test.botanical.lastEpithet"+ taxonNameBase.getId();
}
@Override
- public String getNameCache(BotanicalName taxonNameBase) {
+ public String getNameCache(IBotanicalName taxonNameBase) {
return "test.botanical.nameCache"+ taxonNameBase.getId();
}
@Override
- public String getFullTitleCache(BotanicalName taxonNameBase) {
+ public String getFullTitleCache(IBotanicalName taxonNameBase) {
return "test.botanical.fullTitleCache"+ taxonNameBase.getId();
}
@Override
- public String getTitleCache(BotanicalName object) {
+ public String getTitleCache(IBotanicalName object) {
return "test.botanical.titleCache"+ object.getId();
}
@Override
- public List<TaggedText> getTaggedTitle(BotanicalName taxonName) {
+ public List<TaggedText> getTaggedTitle(IBotanicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getTaggedFullTitle(BotanicalName taxonName) {
+ public List<TaggedText> getTaggedFullTitle(IBotanicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getTaggedName(BotanicalName taxonName) {
+ public List<TaggedText> getTaggedName(IBotanicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getTitleCache(BotanicalName nonViralName, HTMLTagRules htmlTagRules) {
+ public String getTitleCache(IBotanicalName nonViralName, HTMLTagRules htmlTagRules) {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getFullTitleCache(BotanicalName nonViralName,
+ public String getFullTitleCache(IBotanicalName nonViralName,
HTMLTagRules htmlTagRules) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getNomStatusTags(BotanicalName taxonName, boolean includeSeparatorBefore,
+ public List<TaggedText> getNomStatusTags(IBotanicalName taxonName, boolean includeSeparatorBefore,
boolean includeSeparatorAfter) {
// TODO Auto-generated method stub
return null;
import java.util.List;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
import eu.etaxonomy.cdm.strategy.cache.TaggedText;
import eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy;
-public class TestingZoologicalNameCacheStrategy implements INonViralNameCacheStrategy<ZoologicalName> {
+public class TestingZoologicalNameCacheStrategy implements INonViralNameCacheStrategy<IZoologicalName> {
@Override
- public String getAuthorshipCache(ZoologicalName nonViralName) {
+ public String getAuthorshipCache(IZoologicalName nonViralName) {
return "test.zoological.authorshipCache"+ nonViralName.getId();
}
@Override
- public String getLastEpithet(ZoologicalName taxonNameBase) {
+ public String getLastEpithet(IZoologicalName taxonNameBase) {
return "test.zoological.lastEpithet"+ taxonNameBase.getId();
}
@Override
- public String getNameCache(ZoologicalName taxonNameBase) {
+ public String getNameCache(IZoologicalName taxonNameBase) {
return "test.zoological.nameCache"+ taxonNameBase.getId();
}
@Override
- public String getFullTitleCache(ZoologicalName taxonNameBase) {
+ public String getFullTitleCache(IZoologicalName taxonNameBase) {
return "test.zoological.fullTitleCache"+ taxonNameBase.getId();
}
@Override
- public String getTitleCache(ZoologicalName object) {
+ public String getTitleCache(IZoologicalName object) {
return "test.zoological.titleCache"+ object.getId();
}
@Override
- public List<TaggedText> getTaggedTitle(ZoologicalName taxonName) {
+ public List<TaggedText> getTaggedTitle(IZoologicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getTaggedFullTitle(ZoologicalName taxonName) {
+ public List<TaggedText> getTaggedFullTitle(IZoologicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getTaggedName(ZoologicalName taxonName) {
+ public List<TaggedText> getTaggedName(IZoologicalName taxonName) {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getTitleCache(ZoologicalName nonViralName, HTMLTagRules htmlTagRules) {
+ public String getTitleCache(IZoologicalName nonViralName, HTMLTagRules htmlTagRules) {
// TODO Auto-generated method stub
return null;
}
@Override
- public String getFullTitleCache(ZoologicalName nonViralName,
+ public String getFullTitleCache(IZoologicalName nonViralName,
HTMLTagRules htmlTagRules) {
// TODO Auto-generated method stub
return null;
}
@Override
- public List<TaggedText> getNomStatusTags(ZoologicalName taxonName, boolean includeSeparatorBefore,
+ public List<TaggedText> getNomStatusTags(IZoologicalName taxonName, boolean includeSeparatorBefore,
boolean includeSeparatorAfter) {
// TODO Auto-generated method stub
return null;
import org.unitils.spring.annotation.SpringBeanByType;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
import eu.etaxonomy.cdm.model.name.Rank;
// creating new Typedesignation for a new Name:
// 1. new TaxonName with UUID 8564287e-9654-4b8b-a38c-0ccdd9e885db
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("Name1", true);
name1.setUuid(UUID.fromString("8564287e-9654-4b8b-a38c-0ccdd9e885db"));
// 2. new TypeDesignation with uuid ceca086e-e8d3-444e-abfb-c47f76835130
@Test
@ExpectedDataSet
public void testSaveTypeDesignationsCascadeToSpecimen() {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("Name1", true);
name1.setUuid(UUID.fromString("eb41f549-4a70-499b-a9a5-f2314880df07"));
@ExpectedDataSet
//test save from specimen to name via type designation
public void testSaveTypeDesignationsCascadeFromSpecimen() {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("Name1", true);
name1.setUuid(UUID.fromString("7ce3a355-8f7c-4417-a0b3-41869de4f60b"));
@Test
// @ExpectedDataSet
public void testRemoveTypeDesignationsFromName() {
- BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name1.setTitleCache("Name1");
name1.setUuid(UUID.fromString("2cfc05fc-138e-452d-b4ea-8798134c7410"));
- BotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name2.setTitleCache("Name2");
name2.setUuid(UUID.fromString("7a12057d-2e99-471e-ac7e-633f1d0b5686"));
this.endTransaction();
this.startNewTransaction();
- name1 = (BotanicalName)nameDao.load(name1.getUuid());
+ name1 = nameDao.load(name1.getUuid());
Assert.assertNotNull(name1);
Assert.assertEquals("Name1 should have 2 type designations", 2, name1.getTypeDesignations().size());
this.endTransaction();
this.startNewTransaction();
- name1 = (BotanicalName)nameDao.load(name1.getUuid());
+ name1 = nameDao.load(name1.getUuid());
Assert.assertNotNull(name1);
Assert.assertEquals("Name1 should have 1 type designation", 1, name1.getTypeDesignations().size());
this.endTransaction();
this.startNewTransaction();
- name1 = (BotanicalName)nameDao.load(name1.getUuid());
+ name1 = nameDao.load(name1.getUuid());
Assert.assertNotNull(name1);
Assert.assertEquals("Name1 should have no type designations", 0, name1.getTypeDesignations().size());
- name2 = (BotanicalName)nameDao.load(name2.getUuid());
+ name2 = nameDao.load(name2.getUuid());
Assert.assertNotNull(name1);
Assert.assertEquals("Name2 should have 1 type designation", 1, name2.getTypeDesignations().size());
SpecimenTypeDesignation desig1New = (SpecimenTypeDesignation)name2.getTypeDesignations().iterator().next();
this.endTransaction();
this.startNewTransaction();
}
- name2 = (BotanicalName)nameDao.load(name2.getUuid());
+ name2 = nameDao.load(name2.getUuid());
Assert.assertNotNull(name1);
desig1 = (SpecimenTypeDesignation)typeDesignationDao.load(desig1.getUuid());
name2.removeTypeDesignation(desig1);
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
import eu.etaxonomy.cdm.model.description.TextData;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
+ RandomStringUtils.randomAlphabetic(10);
// create a name for the taxon
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setNameCache(randomName, true);
// create nomenclatural reference for taxon name (if left)
import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.common.TimePeriod;
import eu.etaxonomy.cdm.model.molecular.Amplification;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
@ExpectedDataSet
public void testOnSaveOrUpdateNames() {
//names
- BotanicalName name = (BotanicalName)cdmEntityDaoBase.findByUuid(UUID.fromString("a49a3963-c4ea-4047-8588-2f8f15352730"));
+ TaxonNameBase<?,?> 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);
- BotanicalName name2 = (BotanicalName)cdmEntityDaoBase.findByUuid(UUID.fromString("05a438d6-065f-49ef-84db-c7dc2c259975"));
+ TaxonNameBase<?,?> name2 = cdmEntityDaoBase.findByUuid(UUID.fromString("05a438d6-065f-49ef-84db-c7dc2c259975"));
name2.setProtectedFullTitleCache(false);
name2.setProtectedTitleCache(false);
name2.setProtectedNameCache(false);
cdmEntityDaoBase.saveOrUpdate(name2);
Assert.assertEquals(name, cdmEntityDaoBase.findByUuid(name.getUuid()));
- BotanicalName nameTest = (BotanicalName)cdmEntityDaoBase.findByUuid(name.getUuid());
+ IBotanicalName nameTest = cdmEntityDaoBase.findByUuid(name.getUuid());
Assert.assertEquals(name2, cdmEntityDaoBase.findByUuid(name2.getUuid()));
logger.debug("FulltitleCache: "+ cdmEntityDaoBase.findByUuid(name2.getUuid()).getFullTitleCache());
logger.debug("updated: " + cdmEntityDaoBase.findByUuid(name2.getUuid()).getUpdated());
- BotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ TaxonNameBase<?,?> name3 = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
name3.setFullTitleCache("Test: MyBook");
name3.setTitleCache("Test", true);
cdmEntityDaoBase.saveOrUpdate(name3);
List<TaxonNameBase> taxa = cdmEntityDaoBase.findByTitle("Test");
TaxonNameBase<?,?> nameBase = taxa.get (0);
- BotanicalName botName = (BotanicalName)nameBase;
+ IBotanicalName botName = nameBase;
logger.debug("created "+botName.getCreated());
logger.debug("updated: " +botName.getUpdated());
-// BotanicalName name3 = (BotanicalName)cdmEntityDaoBase.findByUuid(UUID.fromString("049a3963-c4ea-4047-8588-2f8f15352730"));
+// IBotanicalName name3 = (IBotanicalName)cdmEntityDaoBase.findByUuid(UUID.fromString("049a3963-c4ea-4047-8588-2f8f15352730"));
// printDataSet(System.err, new String[]{"TaxonNameBase", "Reference"});
}
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationship;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.persistence.dao.name.ITaxonNameDao;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
@DataSet("CdmDeleteListenerTest.xml")
@ExpectedDataSet
public void testOnDelete() throws Exception {
- NonViralName<?> name = (NonViralName<?>)taxonNameDao.findByUuid(uuid);
+ TaxonNameBase<?,?> name = taxonNameDao.findByUuid(uuid);
/**
* Ended up with some horrible hibernate errors otherwise
*/
import org.unitils.dbunit.annotation.DataSets;
import org.unitils.spring.annotation.SpringBeanByType;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
Taxon taxon = Taxon.NewInstance(null, null);
DeterminationEvent detWithTaxonOnlyAndNoName = DeterminationEvent.NewInstance(taxon, unit);
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
Taxon taxon2 = Taxon.NewInstance(name, null);
DeterminationEvent detWithTaxonOnlyAndNameOnTaxon = DeterminationEvent.NewInstance(taxon2, unit);
\r
import eu.etaxonomy.cdm.api.service.INameService;\r
import eu.etaxonomy.cdm.api.service.pager.Pager;\r
-import eu.etaxonomy.cdm.model.name.NonViralName;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.TypeDesignationBase;\r
import io.swagger.annotations.Api;\r
\r
logger.info("doGetNameCache()" + request.getRequestURI());\r
TaxonNameBase<?,?> tnb = getCdmBaseInstance(uuid, response, NAME_CACHE_INIT_STRATEGY);\r
- NonViralName<?> nvn = (NonViralName<?>) tnb;\r
- String nameCacheString = nvn.getNameCache();\r
+ String nameCacheString = tnb.getNameCache();\r
List<String> result = new ArrayList<>();\r
result.add(nameCacheString);\r
return result;\r
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.IdentifiableSource;
import eu.etaxonomy.cdm.model.common.Language;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.reference.Reference;
logger.info("taxon uuid " + taxon.getUuid().toString() + " original hash code : " + System.identityHashCode(taxon) + ", name class " + taxon.getName().getClass().getName());
// update taxon information object with taxon related data
- NonViralName<?> nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
+ INonViralName nvn = CdmBase.deproxy(taxon.getName());
String secTitle = "" ;
String modified = "";
AcceptedNameSearch ans = new AcceptedNameSearch();
ans.setRequest(query);
- for (NonViralName nvn : nameList) {
+ for (INonViralName nvn : nameList) {
// we need to retrieve both taxon uuid of name queried and
// the corresponding accepted taxa.
// reason to return accepted taxa also, is to be able to get from
Synonym synonym = (Synonym) tb;
Taxon accTaxon = synonym.getAcceptedTaxon();
if (accTaxon != null) {
- NonViralName<?> accNvn = CdmBase.deproxy(accTaxon.getName(),NonViralName.class);
+ INonViralName accNvn = CdmBase.deproxy(accTaxon.getName());
Map<String, Map> classificationMap = getClassification(accTaxon, CLASSIFICATION_DEFAULT, false);
ans.addToResponseList(accNvn.getNameCache(),accNvn.getAuthorshipCache(), accNvn.getRank().getTitleCache(), classificationMap);
}
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.location.NamedArea;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.IBook;
private IBook book;
private Reference bookSection;
private TeamOrPersonBase<?> authorship;
- private NonViralName<?> name;
+ private INonViralName name;
private LSID lsid;
private TaxonDescription taxonDescription;
assertNotNull(simpleDarwinRecord.getModified());
assertEquals(taxon.getName().getTitleCache(), simpleDarwinRecord.getScientificName());
- assertEquals(((NonViralName<?>)taxon.getName()).getAuthorshipCache(), simpleDarwinRecord.getScientificNameAuthorship());
- assertEquals(((NonViralName<?>)taxon.getName()).getCitationString(), simpleDarwinRecord.getNamePublishedIn());
+ assertEquals(taxon.getName().getAuthorshipCache(), simpleDarwinRecord.getScientificNameAuthorship());
+ assertEquals(taxon.getName().getCitationString(), simpleDarwinRecord.getNamePublishedIn());
assertEquals(Rank.SPECIES().getLabel(), simpleDarwinRecord.getTaxonRank());
}
import eu.etaxonomy.cdm.model.media.MediaRepresentation;
import eu.etaxonomy.cdm.model.media.MediaUtils;
import eu.etaxonomy.cdm.model.name.INonViralName;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.reference.Reference;
if(parentNode == null){
//if no match found in list, create parentNode
NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();
- NonViralName nonViralName = parser.parseFullName(genus);
- TaxonNameBase taxonNameBase = nonViralName;
+ TaxonNameBase<?,?> taxonNameBase = (TaxonNameBase<?,?>)parser.parseFullName(genus);
//TODO Sec via configurator
Taxon taxon = Taxon.NewInstance(taxonNameBase, null);
parentNode = newClassification.addChildTaxon(taxon, 0, null, null);
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
* @param propertyPaths properties to initialize - see {@link IBeanInitializer#initialize(Object, List)}
* @return a Pager of HybridRelationship instances
*/
- public Pager<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
+ public Pager<HybridRelationship> getHybridNames(INonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);
/**
* Return a List of types related to this name, optionally filtered
}
@Override
- public Pager<HybridRelationship> getHybridNames(NonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
+ public Pager<HybridRelationship> getHybridNames(INonViralName name, HybridRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
Integer numberOfResults = dao.countHybridNames(name, type);
List<HybridRelationship> results = new ArrayList<HybridRelationship>();
protected LuceneSearch prepareFindByFuzzyNameSearch(Class<? extends CdmBase> clazz,
- NonViralName nvn,
+ INonViralName nvn,
float accuracy,
int maxNoOfResults,
List<Language> languages,
logger.info("Name to fuzzy search for : " + name);
// parse the input name
NonViralNameParserImpl parser = new NonViralNameParserImpl();
- NonViralName nvn = parser.parseFullName(name);
+ INonViralName nvn = parser.parseFullName(name);
if(name != null && !name.equals("") && nvn == null) {
throw new ParseException("Could not parse name " + name);
}
logger.info("Name to fuzzy search for : " + name);
// parse the input name
NonViralNameParserImpl parser = new NonViralNameParserImpl();
- NonViralName nvn = parser.parseFullName(name);
+ INonViralName nvn = parser.parseFullName(name);
if(name != null && !name.equals("") && nvn == null) {
throw new ParseException("Could not parse name " + name);
}
import eu.etaxonomy.cdm.model.media.MediaRepresentation;
import eu.etaxonomy.cdm.model.media.MediaUtils;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
List <Synonym> inferredSynonyms = new ArrayList<>();
List<Synonym> inferredSynonymsToBeRemoved = new ArrayList<>();
- HashMap <UUID, ZoologicalName> zooHashMap = new HashMap<>();
+ HashMap <UUID, IZoologicalName> zooHashMap = new HashMap<>();
UUID nameUuid= taxon.getName().getUuid();
- ZoologicalName taxonName = getZoologicalName(nameUuid, zooHashMap);
+ IZoologicalName taxonName = getZoologicalName(nameUuid, zooHashMap);
String epithetOfTaxon = null;
String infragenericEpithetOfTaxon = null;
String infraspecificEpithetOfTaxon = null;
if (node.getClassification().equals(classification)){
if (!node.isTopmostNode()){
TaxonNode parent = node.getParent();
- parent = HibernateProxyHelper.deproxy(parent);
+ parent = CdmBase.deproxy(parent);
TaxonNameBase<?,?> parentName = parent.getTaxon().getName();
- ZoologicalName zooParentName = HibernateProxyHelper.deproxy(parentName, ZoologicalName.class);
- Taxon parentTaxon = HibernateProxyHelper.deproxy(parent.getTaxon());
+ IZoologicalName zooParentName = CdmBase.deproxy(parentName);
+ Taxon parentTaxon = CdmBase.deproxy(parent.getTaxon());
Rank rankOfTaxon = taxonName.getRank();
synonymRelationOfParent);
inferredSynonyms.add(inferredEpithet);
- zooHashMap.put(inferredEpithet.getName().getUuid(), (ZoologicalName)inferredEpithet.getName());
+ zooHashMap.put(inferredEpithet.getName().getUuid(), inferredEpithet.getName());
taxonNames.add(((ZoologicalName)inferredEpithet.getName()).getNameCache());
}
misappliedName);
inferredSynonyms.add(inferredEpithet);
- zooHashMap.put(inferredEpithet.getName().getUuid(), (ZoologicalName)inferredEpithet.getName());
+ zooHashMap.put(inferredEpithet.getName().getUuid(), inferredEpithet.getName());
taxonNames.add(((ZoologicalName)inferredEpithet.getName()).getNameCache());
}
}
if (!taxonNames.isEmpty()){
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
- ZoologicalName name;
+ IZoologicalName name;
if (!synNotInCDM.isEmpty()){
inferredSynonymsToBeRemoved.clear();
for (Synonym synonymRelationOfTaxon:synonymsOfTaxon){
TaxonNameBase synName;
- ZoologicalName inferredSynName;
+ IZoologicalName inferredSynName;
inferredGenus = createInferredGenus(taxon,
zooHashMap, taxonName, epithetOfTaxon,
genusOfTaxon, taxonNames, zooParentName, synonymRelationOfTaxon);
inferredSynonyms.add(inferredGenus);
- zooHashMap.put(inferredGenus.getName().getUuid(), (ZoologicalName)inferredGenus.getName());
+ zooHashMap.put(inferredGenus.getName().getUuid(), inferredGenus.getName());
taxonNames.add(( (ZoologicalName)inferredGenus.getName()).getNameCache());
inferredGenus = createInferredGenus(taxon, zooHashMap, taxonName, infraspecificEpithetOfTaxon, genusOfTaxon, taxonNames, zooParentName, misappliedName);
inferredSynonyms.add(inferredGenus);
- zooHashMap.put(inferredGenus.getName().getUuid(), (ZoologicalName)inferredGenus.getName());
+ zooHashMap.put(inferredGenus.getName().getUuid(), inferredGenus.getName());
taxonNames.add(( (ZoologicalName)inferredGenus.getName()).getNameCache());
}
}
if (!taxonNames.isEmpty()){
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
- ZoologicalName name;
+ IZoologicalName name;
if (!synNotInCDM.isEmpty()){
inferredSynonymsToBeRemoved.clear();
}else if (type.equals(SynonymType.POTENTIAL_COMBINATION_OF())){
Reference sourceReference = null; // TODO: Determination of sourceReference is redundant
- ZoologicalName inferredSynName;
+ IZoologicalName inferredSynName;
//for all synonyms of the parent...
for (Synonym synonymRelationOfParent:synonyMsOfParent){
TaxonNameBase synName;
// Determine the idInSource
String idInSourceParent = getIdInSource(synonymRelationOfParent);
- ZoologicalName parentSynZooName = getZoologicalName(synName.getUuid(), zooHashMap);
+ IZoologicalName parentSynZooName = getZoologicalName(synName.getUuid(), zooHashMap);
String synParentGenus = parentSynZooName.getGenusOrUninomial();
String synParentInfragenericName = null;
String synParentSpecificEpithet = null;
for (Synonym synonymRelationOfTaxon:synonymsOfTaxon){
- ZoologicalName zooSynName = getZoologicalName(synonymRelationOfTaxon.getName().getUuid(), zooHashMap);
+ IZoologicalName zooSynName = getZoologicalName(synonymRelationOfTaxon.getName().getUuid(), zooHashMap);
potentialCombination = createPotentialCombination(idInSourceParent, parentSynZooName, zooSynName,
synParentGenus,
synParentInfragenericName,
taxon.addSynonym(potentialCombination, SynonymType.POTENTIAL_COMBINATION_OF());
inferredSynonyms.add(potentialCombination);
- zooHashMap.put(potentialCombination.getName().getUuid(), (ZoologicalName)potentialCombination.getName());
+ zooHashMap.put(potentialCombination.getName().getUuid(), potentialCombination.getName());
taxonNames.add(( (ZoologicalName)potentialCombination.getName()).getNameCache());
}
// Determine the idInSource
String idInSourceParent = getIdInSource(misappliedParent);
- ZoologicalName parentSynZooName = getZoologicalName(misappliedParentName.getUuid(), zooHashMap);
+ IZoologicalName parentSynZooName = getZoologicalName(misappliedParentName.getUuid(), zooHashMap);
String synParentGenus = parentSynZooName.getGenusOrUninomial();
String synParentInfragenericName = null;
String synParentSpecificEpithet = null;
for (TaxonRelationship taxonRelationship: taxonRelListTaxon){
Taxon misappliedName = taxonRelationship.getFromTaxon();
- ZoologicalName zooMisappliedName = getZoologicalName(misappliedName.getName().getUuid(), zooHashMap);
+ IZoologicalName zooMisappliedName = getZoologicalName(misappliedName.getName().getUuid(), zooHashMap);
potentialCombination = createPotentialCombination(
idInSourceParent, parentSynZooName, zooMisappliedName,
synParentGenus,
taxon.addSynonym(potentialCombination, SynonymType.POTENTIAL_COMBINATION_OF());
inferredSynonyms.add(potentialCombination);
- zooHashMap.put(potentialCombination.getName().getUuid(), (ZoologicalName)potentialCombination.getName());
+ zooHashMap.put(potentialCombination.getName().getUuid(), potentialCombination.getName());
taxonNames.add(( (ZoologicalName)potentialCombination.getName()).getNameCache());
}
}
if (!taxonNames.isEmpty()){
List<String> synNotInCDM = dao.taxaByNameNotInDB(taxonNames);
- ZoologicalName name;
+ IZoologicalName name;
if (!synNotInCDM.isEmpty()){
inferredSynonymsToBeRemoved.clear();
for (Synonym syn :inferredSynonyms){
try{
- name = (ZoologicalName) syn.getName();
+ name = syn.getName();
}catch (ClassCastException e){
name = getZoologicalName(syn.getName().getUuid(), zooHashMap);
}
}
private Synonym createPotentialCombination(String idInSourceParent,
- ZoologicalName parentSynZooName, ZoologicalName zooSynName, String synParentGenus,
+ IZoologicalName parentSynZooName, IZoologicalName zooSynName, String synParentGenus,
String synParentInfragenericName, String synParentSpecificEpithet,
- TaxonBase syn, HashMap<UUID, ZoologicalName> zooHashMap) {
+ TaxonBase syn, HashMap<UUID, IZoologicalName> zooHashMap) {
Synonym potentialCombination;
Reference sourceReference;
- ZoologicalName inferredSynName;
+ IZoologicalName inferredSynName;
HibernateProxyHelper.deproxy(syn);
// Set sourceReference
}
private Synonym createInferredGenus(Taxon taxon,
- HashMap<UUID, ZoologicalName> zooHashMap, ZoologicalName taxonName,
+ HashMap<UUID, IZoologicalName> zooHashMap, IZoologicalName taxonName,
String epithetOfTaxon, String genusOfTaxon,
- List<String> taxonNames, ZoologicalName zooParentName,
+ List<String> taxonNames, IZoologicalName zooParentName,
TaxonBase syn) {
Synonym inferredGenus;
TaxonNameBase synName;
- ZoologicalName inferredSynName;
+ IZoologicalName inferredSynName;
synName =syn.getName();
HibernateProxyHelper.deproxy(syn);
//logger.warn(sourceReference.getTitleCache());
synName = syn.getName();
- ZoologicalName synZooName = getZoologicalName(synName.getUuid(), zooHashMap);
+ IZoologicalName synZooName = getZoologicalName(synName.getUuid(), zooHashMap);
String synSpeciesEpithetName = synZooName.getSpecificEpithet();
/* if (synonymsEpithet != null && !synonymsEpithet.contains(synSpeciesEpithetName)){
synonymsEpithet.add(synSpeciesEpithetName);
}
private Synonym createInferredEpithets(Taxon taxon,
- HashMap<UUID, ZoologicalName> zooHashMap, ZoologicalName taxonName,
+ HashMap<UUID, IZoologicalName> zooHashMap, IZoologicalName taxonName,
String epithetOfTaxon, String infragenericEpithetOfTaxon,
String infraspecificEpithetOfTaxon, List<String> taxonNames,
TaxonNameBase parentName, TaxonBase syn) {
Synonym inferredEpithet;
TaxonNameBase<?,?> synName;
- ZoologicalName inferredSynName;
+ IZoologicalName inferredSynName;
HibernateProxyHelper.deproxy(syn);
// Determine the idInSource
}
synName = syn.getName();
- ZoologicalName zooSynName = getZoologicalName(synName.getUuid(), zooHashMap);
+ IZoologicalName zooSynName = getZoologicalName(synName.getUuid(), zooHashMap);
String synGenusName = zooSynName.getGenusOrUninomial();
String synInfraGenericEpithet = null;
String synSpecificEpithet = null;
}
/**
- * Returns an existing ZoologicalName or extends an internal hashmap if it does not exist.
+ * Returns an existing IZoologicalName or extends an internal hashmap if it does not exist.
* Very likely only useful for createInferredSynonyms().
* @param uuid
* @param zooHashMap
* @return
*/
- private ZoologicalName getZoologicalName(UUID uuid, HashMap <UUID, ZoologicalName> zooHashMap) {
- ZoologicalName taxonName =nameDao.findZoologicalNameByUUID(uuid);
+ private IZoologicalName getZoologicalName(UUID uuid, HashMap <UUID, IZoologicalName> zooHashMap) {
+ IZoologicalName taxonName =nameDao.findZoologicalNameByUUID(uuid);
if (taxonName == null) {
taxonName = zooHashMap.get(uuid);
}
import org.springframework.beans.factory.annotation.Autowired;
import eu.etaxonomy.cdm.api.service.INameService;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.validation.annotation.NoDuplicateNames;
public class NoDuplicateNamesValidator implements
- ConstraintValidator<NoDuplicateNames,NonViralName> {
+ ConstraintValidator<NoDuplicateNames,TaxonNameBase<?,?>> {
private static Set<String> includeProperties;
public void initialize(NoDuplicateNames noDuplicateNames) { }
@Override
- public boolean isValid(NonViralName name, ConstraintValidatorContext constraintContext) {
+ public boolean isValid(TaxonNameBase<?,?> name, ConstraintValidatorContext constraintContext) {
if(name == null) {
return true;
} else {
import eu.etaxonomy.cdm.api.service.IReferenceService;
import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
Taxon taxon = Taxon.NewInstance(TaxonNameFactory.NewNonViralInstance(Rank.SERIES()), sec);
taxon.setTitleCache("Tax" + "CdmCacher", true);
taxonService.save(taxon);
- NonViralName<?> nvn = (NonViralName<?>)taxon.getName();
+ INonViralName nvn = taxon.getName();
String nameCache = nvn.getNameCache();
logger.warn("name cache : " + nameCache);
}
import eu.etaxonomy.cdm.model.agent.Team;
import eu.etaxonomy.cdm.model.common.Annotation;
import eu.etaxonomy.cdm.model.location.Point;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.strategy.merge.MergeException;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
person.setNomenclaturalTitle(nomTitle);
Annotation annotation = Annotation.NewDefaultLanguageInstance("Meine annotation");
person.setContact(getContact());
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setCombinationAuthorship(person);
person.addAnnotation(annotation);
Annotation annotation = Annotation.NewDefaultLanguageInstance("Meine annotation");
team.addAnnotation(annotation);
team.setContact(getContact());
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setCombinationAuthorship(team);
service.save(team);
Annotation annotation2 = Annotation.NewDefaultLanguageInstance("Meine annotation2");
team.addAnnotation(annotation2);
team.setContact(getContact());
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> 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();
- TaxonNameBase<?, ?> nameBase = parser.parseFullName(strName);
+ TaxonNameBase<?,?> nameBase = (TaxonNameBase<?,?>)parser.parseFullName(strName);
Taxon taxon = Taxon.NewInstance(nameBase, null);
map.put(strName, taxon);
}
import eu.etaxonomy.cdm.model.common.Annotation;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.common.Language;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
@DataSet
@Ignore
public final void testGetReferencingObjects() {
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setTitleCache("A name", true);
Reference ref1 = ReferenceFactory.newArticle();
Taxon taxon = Taxon.NewInstance(name, ref1);
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
// objects in the object graph (including teamMembers) will have values of
// initialized=false and session=null
- NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
+ INonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
// normally this call should throw a lazy loading exception since
// the combinationAuthorship object is not initialized, but
// objects in the object graph (including teamMembers) will have a new
// session attached implying that all the following calls will succeed
- NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
+ INonViralName nvn = CdmBase.deproxy(taxon.getName());
Team team = CdmBase.deproxy(nvn.getCombinationAuthorship(),Team.class);
taxonService.update(taxon);
// objects in the object graph (including teamMembers) will have a new
// session attached implying that all the following calls will succeed
- nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
- team = CdmBase.deproxy(nvn.getCombinationAuthorship(),Team.class);
+ nvn = CdmBase.deproxy(taxon.getName());
+ team = CdmBase.deproxy(nvn.getCombinationAuthorship(), Team.class);
taxonService.update(taxon);
// ---- loading taxon with findTaxonByUuid ----
taxon = (Taxon)taxonService.findTaxonByUuid(taxonUuid, TAXON_INIT_STRATEGY);
- NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
- Team team = CdmBase.deproxy(nvn.getCombinationAuthorship(),Team.class);
+ INonViralName nvn = CdmBase.deproxy(taxon.getName());
+ Team team = CdmBase.deproxy(nvn.getCombinationAuthorship(), Team.class);
team.setProtectedTitleCache(false);
try {
// objects in the object graph (including teamMembers) will have values of
// initialized=false and session=null
- NonViralName nvn = CdmBase.deproxy(taxon.getName(),NonViralName.class);
+ INonViralName nvn = CdmBase.deproxy(taxon.getName());
// normally this call should throw a lazy loading exception since
// the combinationAuthorship object is not initialized, but
import eu.etaxonomy.cdm.model.common.MarkerType;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.common.VocabularyEnum;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
termService.save(identifierType2);
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
Taxon tb = Taxon.NewInstance(name, null);
tb.addIdentifier("ext-1234", identifierType1);
name.addIdentifier("ext-name12", identifierType2);
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
final String[] tableNames = new String[]{"USERACCOUNT", "TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase"};
// printDataSetWithNull(System.err, true, null);
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> nameWithBasionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
nameWithBasionym.setTitleCache("nameWithBasionym", true);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1);
if (!result.isOk()){
Exception e = result.getExceptions().iterator().next();
} else{
Assert.fail();
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
nameWithBasionym = name1.getNameRelations().iterator().next().getToName();
nameWithBasionym.removeBasionyms();
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
}
// "DescriptionElementBase",
// "AGENTBASE", "USERACCOUNT", "PERMISSIONGROUP", "USERACCOUNT_PERMISSIONGROUP", "USERACCOUNT_GRANTEDAUTHORITYIMPL", "GRANTEDAUTHORITYIMPL"});
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> nameWithBasionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
nameWithBasionym.setTitleCache("nameWithBasionym", true);
commitAndStartNewTransaction(tableNames);
NameDeletionConfigurator config = new NameDeletionConfigurator();
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1.getUuid(), config);
if (result.isOk()){
Assert.fail("This should throw an error as long as name relationships exist.");
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
//ignore is basionym for
config.setIgnoreIsBasionymFor(true);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
nameService.delete(name1.getUuid(), config);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
}
public void testDeleteTaxonNameBaseConfiguratorWithNameRelationsAll() {
final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> nameWithBasionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
nameWithBasionym.setTitleCache("nameWithBasionym", true);
commitAndStartNewTransaction(tableNames);
NameDeletionConfigurator config = new NameDeletionConfigurator();
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1.getUuid(), config);
if (result.isOk()){
Assert.fail("Delete should throw an error as long as name relationships exist.");
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
//ignore all name relationships
config.setRemoveAllNameRelationships(true);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
result = nameService.delete(name1.getUuid(), config);
logger.debug(result);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
}
public void testDeleteTaxonNameBaseConfiguratorWithHasBasionym() {
final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> basionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
basionym.setTitleCache("basionym", true);
NameDeletionConfigurator config = new NameDeletionConfigurator();
config.setIgnoreHasBasionym(false);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1.getUuid(), config);
if (result.isOk()){
Assert.fail("Delete should throw an error as long as name relationships exist.");
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
//ignore has basionym
config.setIgnoreHasBasionym(true);
try {
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
result = nameService.delete(name1.getUuid(), config);
logger.debug(result);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
} catch (Exception e) {
Assert.fail("Delete should not throw an error for .");
public void testDeleteTaxonNameBaseWithHybridRelations() {
final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
- NonViralName<?> parent = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> parent = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
parent.setTitleCache("parent", true);
- NonViralName<?> child = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> child = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
child.setTitleCache("child", true);
HybridRelationshipType relType = (HybridRelationshipType)termService.find(HybridRelationshipType.FIRST_PARENT().getUuid());
//parent
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1);
if (result.isError()){
Assert.fail("Delete should throw NO exception when deleting a hybrid child: " + result.getExceptions().iterator().next().getMessage());
}
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
- parent = (NonViralName<?>)nameService.find(parent.getUuid());
+ parent = nameService.find(parent.getUuid());
Assert.assertEquals("'Parent' should not be a parent anymore.", 0,parent.getHybridParentRelations().size());
//child
if (result.isOk()){
Assert.fail("Delete should throw an error as long as hybrid child exist.");
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
name1.removeHybridChild(child);
}
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
}
public void testDeleteTaxonNameBaseInConcept() {
final String[] tableNames = new String[]{"TaxonNameBase","TaxonBase"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> basionym = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
basionym.setTitleCache("basionym", true);
Assert.fail("Delete should throw NO error ");
}
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should still be in database",name1);
taxon = (Taxon)taxonService.find(taxon.getUuid());
Assert.assertNotNull("Taxon should still be in database",taxon);
public void testDeleteTaxonNameBaseAsStoredUnder() {
final String[] tableNames = new String[]{"TaxonNameBase","SpecimenOrObservationBase"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
DerivedUnit specimen = DerivedUnit.NewPreservedSpecimenInstance();
specimen.setStoredUnder(name1);
}
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(uuidName1);
+ name1 = nameService.find(uuidName1);
Assert.assertNotNull("Name should still be in database",name1);
specimen = (DerivedUnit)occurrenceService.find(specimen.getUuid());
Assert.assertNotNull("Specimen should still be in database",name1);
nameService.delete(name1); //should throw no exception
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(uuidName1);
+ name1 = nameService.find(uuidName1);
Assert.assertNull("Name should not be in database anymore",name1);
specimen = (DerivedUnit)occurrenceService.find(specimen.getUuid());
Assert.assertNotNull("Specimen should still be in database",specimen);
public void testDeleteTaxonNameBaseInSource() {
final String[] tableNames = new String[]{"TaxonNameBase","DescriptionBase","TaxonBase","OriginalSourceBase","DescriptionElementBase"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
TaxonNameBase<?,?> taxonName = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
taxonName.setTitleCache("taxonName", true);
nameService.save(name1);
try {
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
nameService.delete(name1);
Assert.fail("Delete should throw an error as long as name is used in a source.");
} catch (Exception e) {
Assert.fail("Unexpected error occurred when trying to delete taxon name: " + e.getMessage());
}
}
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
taxon = (Taxon)taxonService.find(taxon.getUuid());
Assert.assertNotNull("Taxon should still be in database",name1);
nameService.delete(name1); //should throw now exception
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
taxon = (Taxon)taxonService.find(taxon.getUuid());
Assert.assertNotNull("Taxon should still be in database",taxon);
public void testDeleteTaxonNameBaseAsType() {
final String[] tableNames = new String[]{"TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name used as type", true);
- NonViralName<?> higherName = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
+ TaxonNameBase<?,?> higherName = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
higherName.setTitleCache("genus name", true);
NameTypeDesignationStatus typeStatus = (NameTypeDesignationStatus)termService.find(NameTypeDesignationStatus.AUTOMATIC().getUuid());
boolean addToAllHomotypicNames = true;
nameService.save(higherName);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1);
if (result.isOk()){
Assert.fail("This should throw an error because name is used in a type designation.");
}
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNotNull("Name should still be in database",name1);
- higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
+ higherName = nameService.find(higherName.getUuid());
higherName.getNameTypeDesignations().iterator().next().removeType(); //keeps the designation but removes the name from it
// nameService.deleteTypeDesignation(higherName,commitAndStartNewTransaction(tableNames) ); //deletes the complete designation //both options can be used
nameService.delete(name1); //should throw now exception
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
- higherName = (NonViralName<?>)nameService.find(higherName.getUuid());
+ higherName = nameService.find(higherName.getUuid());
Assert.assertNotNull("Higher name should still exist in database",higherName);
Assert.assertEquals("Higher name should not have type designations anymore",1, higherName.getTypeDesignations().size());
}
public void testDeleteTaxonNameBase() {
final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1", true);
//TaxonNameDescription
nameService.saveOrUpdate(name1);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
DeleteResult result = nameService.delete(name1);//should throw now exception
setComplete();
endTransaction();
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
Assert.assertNull("Name should not be in database anymore",name1);
// printDataSet(System.out, tableNames);
nameService.saveOrUpdate(name1);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
nameService.delete(name1); //should throw now exception
if (!result.isOk()){
commitAndStartNewTransaction(tableNames);
// printDataSet(System.out, tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
result = nameService.delete(name1); //should throw now exception
if (!result.isOk()){
final String[] tableNames = new String[]{"TaxonNameBase","NameRelationship","HybridRelationship","DescriptionBase","NomenclaturalStatus","TaxonBase","SpecimenOrObservationBase","OriginalSourceBase","DescriptionElementBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase"};
//Type Designations for homotypical group with > 1 names
- NonViralName<?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name1.setTitleCache("Name1 with type designation", true);
- NonViralName<?> name2 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+ TaxonNameBase<?,?> name2 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
name2.setTitleCache("Name2 with type designation", true);
name2.setHomotypicalGroup(name1.getHomotypicalGroup());
nameService.saveOrUpdate(name1);
commitAndStartNewTransaction(tableNames);
- name1 = (NonViralName<?>)nameService.find(name1.getUuid());
+ name1 = nameService.find(name1.getUuid());
nameService.delete(name1); //should throw now exception
"TaxonNameBase","TypeDesignationBase","TaxonNameBase_TypeDesignationBase",
"SpecimenOrObservationBase"};
-// BotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+// IBotanicalName name1 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
// name1.setTitleCache("Name1");
// name1.setUuid(UUID.fromString("6dbd41d1-fe13-4d9c-bb58-31f051c2c384"));
//
-// BotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
+// IBotanicalName name2 = TaxonNameFactory.NewBotanicalInstance(getSpeciesRank());
// name2.setTitleCache("Name2");
// name2.setUuid(UUID.fromString("f9e9c13f-5fa5-48d3-88cf-712c921a099e"));
//
-// BotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
+// IBotanicalName name3 = TaxonNameFactory.NewBotanicalInstance(getGenusRank());
// name3.setTitleCache("Name3");
// name3.setUuid(UUID.fromString("e1e66264-f16a-4df9-80fd-6ab5028a3c28"));
//
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.model.taxon.Synonym;
SecurityContext context = SecurityContextHolder.getContext();
context.setAuthentication(authentication);
- ZoologicalName newName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> newName = TaxonNameFactory.NewZoologicalInstance(Rank.SPECIES());
newName.setTitleCache("Newby taxonEditor", true);
UUID uuid = nameService.saveOrUpdate(newName);
commitAndStartNewTransaction(null);
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
import eu.etaxonomy.cdm.model.description.TextData;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
MyCounter taxonContextCounter = new MyCounter();
// create a name for the taxon
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setNameCache(randomName, true);
// create nomenclatural reference for taxon name (if left)
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
import eu.etaxonomy.cdm.model.description.TextData;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
+ RandomStringUtils.randomAlphabetic(10);
// create a name for the taxon
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
name.setNameCache(randomName, true);
// create nomenclatural reference for taxon name (if left)
import eu.etaxonomy.cdm.model.description.PolytomousKey;
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
assertNull(t1);
Taxon newTaxon = (Taxon)taxonService.load(taxUUID);
assertNull(newTaxon);
- BotanicalName name = (BotanicalName)nameService.load(nameUUID);
+ IBotanicalName name = nameService.load(nameUUID);
assertNull(name);
* `- Pinus pampa
*/
Classification classification = Classification.NewInstance("Classification");
- BotanicalName abiesName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName abiesName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
abiesName.setGenusOrUninomial("Abies");
Taxon abies = Taxon.NewInstance(abiesName, null);
- BotanicalName abiesAlbaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName abiesAlbaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
abiesAlbaName.setGenusOrUninomial("Abies");
abiesAlbaName.setSpecificEpithet("alba");
Taxon abiesAlba = Taxon.NewInstance(abiesAlbaName, null);
- BotanicalName pinusName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName pinusName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
pinusName.setGenusOrUninomial("Pinus");
Taxon pinus = Taxon.NewInstance(pinusName, null);
- BotanicalName pinusPampaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName pinusPampaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
pinusPampaName.setGenusOrUninomial("Pinus");
pinusPampaName.setSpecificEpithet("pampa");
Taxon pinusPampa = Taxon.NewInstance(pinusPampaName, null);
- BotanicalName abiesBalsameaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName abiesBalsameaName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
abiesBalsameaName.setGenusOrUninomial("Abies");
abiesBalsameaName.setSpecificEpithet("balsamea");
Taxon abiesBalsamea = Taxon.NewInstance(abiesBalsameaName, null);
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
private Reference reference;
private SynonymType homoTypicSynonymType;
private SynonymType heteroTypicSynonymType;
- private NonViralName<?> s1n;
- private NonViralName<?> t2n;
- private NonViralName<?> t1n;
- private NonViralName<?> s2n;
+ private INonViralName s1n;
+ private INonViralName t2n;
+ private INonViralName t1n;
+ private TaxonNameBase<?,?> s2n;
/**
* @throws java.lang.Exception
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NameRelationship;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
-import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
Reference reference = ReferenceFactory.newGeneric();
String referenceDetail = "test";
- NonViralName<?> t1n = TaxonNameFactory.NewNonViralInstance(null);
+ INonViralName t1n = TaxonNameFactory.NewNonViralInstance(null);
Taxon t1 = Taxon.NewInstance(t1n, reference);
- NonViralName<?> t2n = TaxonNameFactory.NewNonViralInstance(null);
+ INonViralName t2n = TaxonNameFactory.NewNonViralInstance(null);
Taxon t2 = Taxon.NewInstance(t2n, reference);
- NonViralName<?> s1n = TaxonNameFactory.NewNonViralInstance(null);
+ INonViralName s1n = TaxonNameFactory.NewNonViralInstance(null);
Synonym s1 = Synonym.NewInstance(s1n, reference);
t1.addSynonym(s1, heteroTypicSynonymType);
service.saveOrUpdate(t1);
import eu.etaxonomy.cdm.model.location.Country;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.NonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
for (int i = 0; i < list.size(); i++) {
String nameCache = "";
if (list.get(i) instanceof NonViralName) {
- nameCache = ((NonViralName<?>) list.get(i)).getNameCache();
+ nameCache = ((INonViralName) list.get(i)).getNameCache();
} else if (list.get(i) instanceof TaxonBase) {
TaxonNameBase<?,?> taxonNameBase = ((TaxonBase) list.get(i)).getName();
nameCache = taxonNameBase.getNameCache();
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.name.BotanicalName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.reference.Reference;
citationRef.setTitleCache("Sp. lunarum", true);
//genus taxon with Name, combinationAuthor,
- BotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
+ IBotanicalName botName = TaxonNameFactory.NewBotanicalInstance(Rank.GENUS());
botName.setTitleCache("Hieracium L.", true);
botName.setGenusOrUninomial("Hieracium");
botName.setCombinationAuthorship(Person.NewInstance());
import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.location.NamedArea;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
boolean exists = appCtr.getUserService().userExists("admin");
try {
- BotanicalName name = TaxonNameFactory.NewBotanicalInstance(null);
+ IBotanicalName name = TaxonNameFactory.NewBotanicalInstance(null);
String nameCache = "testName";
name.setNameCache(nameCache);
name.setTitleCache(nameCache, true);
// CdmPersistentDataSource.NewInstance("localH2");
CdmApplicationController appCtr = CdmApplicationController.NewInstance(ds, validation);
try {
- BotanicalName botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
- BotanicalName botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
- BotanicalName hybridName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> botName1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ TaxonNameBase<?,?> botName2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
+ IBotanicalName hybridName = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES());
botName1.addRelationshipToName(botName2, NameRelationshipType.ORTHOGRAPHIC_VARIANT(), null);
UUID uuid1 = botName1.getUuid();
UUID uuid2 = botName2.getUuid();
try {
- Logger loggerTrace = logger.getLogger("org.hibernate.type");
+ Logger loggerTrace = Logger.getLogger("org.hibernate.type");
loggerTrace.setLevel(Level.TRACE);
System.out.println(logger.getName());
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.common.TermVocabulary;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
-import eu.etaxonomy.cdm.model.name.NonViralName;
+import eu.etaxonomy.cdm.model.name.IBotanicalName;
+import eu.etaxonomy.cdm.model.name.INonViralName;
+import eu.etaxonomy.cdm.model.name.IZoologicalName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
-import eu.etaxonomy.cdm.model.name.ZoologicalName;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.model.taxon.Synonym;
public void testAppController() {
logger.info("Create name objects...");
- NonViralName<?> nvn = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ INonViralName nvn = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
- BotanicalName bn = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());
- ZoologicalName zn = TaxonNameFactory.NewZoologicalInstance(Rank.FAMILY());
+ IBotanicalName bn = TaxonNameFactory.NewBotanicalInstance(Rank.SUBSPECIES());
+ IZoologicalName zn = TaxonNameFactory.NewZoologicalInstance(Rank.FAMILY());
logger.info("Create reference objects...");
import eu.etaxonomy.cdm.model.common.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.location.Country;\r
import eu.etaxonomy.cdm.model.location.NamedArea;\r
-import eu.etaxonomy.cdm.model.name.BotanicalName;\r
import eu.etaxonomy.cdm.model.name.NameRelationship;\r
import eu.etaxonomy.cdm.model.name.NameRelationshipType;\r
import eu.etaxonomy.cdm.model.name.Rank;\r
+import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
logger.info("Testing testRemoveNameRelationship()");\r
TransactionStatus txStatus = appCtr.startTransaction();\r
\r
- BotanicalName name1, name2;\r
+ TaxonNameBase<?,?> name1, name2;\r
AgentBase linne = appCtr.getAgentService().find(UUID.fromString("f6272e48-5b4e-40c1-b4e9-ee32334fa19f"));\r
name1 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES(),"Name1",null,"arvensis",null,(TeamOrPersonBase)linne,null,"p.1", null);\r
name2 = TaxonNameFactory.NewBotanicalInstance(Rank.SPECIES(),"Name2",null,"lanzae",null,(TeamOrPersonBase)linne,null,"p.2", null);\r
BGBM BDI Projects / cdmlib.git / commitdiff