} else if (record.getString(KINGDOM).equals(BACTERIA)){
name = TaxonNameFactory.NewBacterialInstance(rank);
} else{
- name = TaxonNameBase.NewNonViralInstance(rank);
+ name = TaxonNameFactory.NewNonViralInstance(rank);
}
} else{
- name = TaxonNameBase.NewNonViralInstance(rank);
+ name = TaxonNameFactory.NewNonViralInstance(rank);
}
}
if (record.has(GENUS)){
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.media.Media;
-import eu.etaxonomy.cdm.model.name.BotanicalName;
import eu.etaxonomy.cdm.model.name.ITaxonNameBase;
import eu.etaxonomy.cdm.model.name.NameRelationshipType;
import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
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.reference.INomenclaturalReference;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
}else if (nc.isKindOf(NomenclaturalCode.ICNAFP)){
name = TaxonNameBase.NewBotanicalInstance(taxonBase.getName().getRank());
} else{
- name = TaxonNameBase.NewNonViralInstance(taxonBase.getName().getRank());
+ name = TaxonNameFactory.NewNonViralInstance(taxonBase.getName().getRank());
}
name.setTitleCache(synonymNameStr, true);
if (name != null){
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
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 fr.lis.ikeyplus.IO.SDDSaxParser;
import fr.lis.ikeyplus.model.DataSet;
import fr.lis.ikeyplus.model.ICharacter;
pkNode = createPkNode(null, statement);
//TODO handle rank
- NonViralName<?> nonViralName = TaxonNameBase.NewNonViralInstance(Rank.UNKNOWN_RANK());
+ NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.UNKNOWN_RANK());
nonViralName.setTitleCache(taxon.getName(), true);
eu.etaxonomy.cdm.model.taxon.Taxon cdmTaxon = eu.etaxonomy.cdm.model.taxon.Taxon.NewInstance(
nonViralName, null); //FIXME !!!!!!
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
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
\r
NonViralName<?> tnb = null;\r
if (!id.equals("")) {\r
- tnb = TaxonNameBase.NewNonViralInstance(defaultRank);\r
+ tnb = TaxonNameFactory.NewNonViralInstance(defaultRank);\r
IdentifiableSource source = null;\r
if (isNotBlank(uri)) {\r
//TODO type\r
private Taxon handleCDNoScope(Namespace sddNamespace,\r
SDDImportState cdmState, Element elCodedDescription ) {\r
Taxon taxon = null;\r
- NonViralName<?> nonViralName = TaxonNameBase.NewNonViralInstance(defaultRank);\r
+ NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(defaultRank);\r
String id = new String("" + taxonNamesCount);\r
IdentifiableSource source = IdentifiableSource.NewDataImportInstance(id, "TaxonName");\r
importRepresentation(elCodedDescription, sddNamespace, nonViralName, id, cdmState);\r
}else if (state.getDataHolder().getNomenclatureCode().equals(NomenclaturalCode.ICZN)){
taxonName = TaxonNameBase.NewZoologicalInstance(rank);
}else{
- taxonName = TaxonNameBase.NewNonViralInstance(rank);
+ taxonName = TaxonNameFactory.NewNonViralInstance(rank);
}
taxonName.setFullTitleCache(scientificName,true);
taxonName.setTitleCache(scientificName, true);
if (problem) {
logger.info("Problem im setTaxonNameByType ");
- TaxonNameBase<?,?> taxonName = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setFullTitleCache(fullName, true);
return taxonName;
}
- TaxonNameBase<?,?> tn = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> tn = TaxonNameFactory.NewNonViralInstance(null);
return tn;
}
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignation;
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
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.occurrence.Collection;
import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
if (nc != null){
name = nc.getNewTaxonNameInstance(rank);
}else{
- name = TaxonNameBase.NewNonViralInstance(rank);
+ name = TaxonNameFactory.NewNonViralInstance(rank);
}
if (StringUtils.isNotBlank(commonDetermination.genus)){
name.setGenusOrUninomial(commonDetermination.genus);
* @return
*/
private NonViralName<?> makeTaxonName(SpecimenCdmExcelImportState state, DeterminationLight determinationLight) {
- NonViralName<?> name = TaxonNameBase.NewNonViralInstance(null);
+ NonViralName<?> name = TaxonNameFactory.NewNonViralInstance(null);
NomenclaturalCode nc = state.getConfig().getNomenclaturalCode();
if (nc != null){
name = (NonViralName<?>)nc.getNewTaxonNameInstance(null);
import eu.etaxonomy.cdm.model.media.Media;
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;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
taxonName = parseScientificName(scientificName);
}
else{
- taxonName = TaxonNameBase.NewNonViralInstance(null);
+ taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setTitleCache(scientificName, true);
}
getNameService().save(taxonName);
}
if(nomenclatureCode == null){
- taxonName = TaxonNameBase.NewNonViralInstance(null);
+ taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setTitleCache(scientificName, true);
return taxonName;
}
// }
//TODO: parsing of ViralNames?
if(problem){
- taxonName = TaxonNameBase.NewNonViralInstance(null);
+ taxonName = TaxonNameFactory.NewNonViralInstance(null);
taxonName.setTitleCache(scientificName, true);
}
return taxonName;
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;
if (nomCode != null){
nameBase = nomCode.getNewTaxonNameInstance(rank);
}else{
- nameBase = TaxonNameBase.NewNonViralInstance(rank);
+ nameBase = TaxonNameFactory.NewNonViralInstance(rank);
}
childName = "Simple";
obligatory = true;
import eu.etaxonomy.cdm.model.description.CommonTaxonName;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
+import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.Classification;\r
import eu.etaxonomy.cdm.model.taxon.Synonym;\r
\r
\r
} else{\r
- basionymName = TaxonNameBase.NewNonViralInstance(name.getRank());\r
+ basionymName = TaxonNameFactory.NewNonViralInstance(name.getRank());\r
childName = "RelatedName";\r
obligatory = true;\r
Element elName = XmlHelp.getSingleChildElement(success, elBasionym, childName, tcsNamespace, obligatory);\r
}else{\r
String title = elToTaxonConcept.getTextNormalize();\r
//TODO synonym?\r
- TaxonNameBase<?,?> taxonName = TaxonNameBase.NewNonViralInstance(null);\r
+ TaxonNameBase<?,?> taxonName = TaxonNameFactory.NewNonViralInstance(null);\r
taxonName.setTitleCache(title, true);\r
logger.warn("Free text related taxon seems to be bug in TCS");\r
if (isSynonym){\r
// *************** FACTORY METHODS ********************************/
- /**
- * Creates a new non viral taxon name instance
- * only containing its {@link common.Rank rank} and
- * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.
- *
- * @param rank the rank to be assigned to <i>this</i> non viral taxon name
- * @see #NewInstance(Rank, HomotypicalGroup)
- * @see #NonViralName(Rank, HomotypicalGroup)
- * @see #NonViralName()
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, Reference, String, HomotypicalGroup)
- * @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
- * @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
- * @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
- */
- public static NonViralName NewNonViralInstance(Rank rank){
- return new NonViralName(rank, null);
- }
-
- /**
- * Creates a new non viral taxon name instance
- * only containing its {@link common.Rank rank},
- * its {@link HomotypicalGroup homotypical group} and
- * the {@link eu.etaxonomy.cdm.strategy.cache.name.NonViralNameDefaultCacheStrategy default cache strategy}.
- * The new non viral taxon name instance will be also added to the set of
- * non viral taxon names belonging to this homotypical group.
- *
- * @param rank the rank to be assigned to <i>this</i> non viral taxon name
- * @param homotypicalGroup the homotypical group to which <i>this</i> non viral taxon name belongs
- * @see #NewInstance(Rank)
- * @see #NonViralName(Rank, HomotypicalGroup)
- * @see #NonViralName()
- * @see #NonViralName(Rank, String, String, String, String, TeamOrPersonBase, Reference, String, HomotypicalGroup)
- * @see eu.etaxonomy.cdm.strategy.cache.name.INonViralNameCacheStrategy
- * @see eu.etaxonomy.cdm.strategy.cache.name.INameCacheStrategy
- * @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
- */
- public static NonViralName NewNonViralInstance(Rank rank, HomotypicalGroup homotypicalGroup){
- return new NonViralName(rank, homotypicalGroup);
- }
-
/**
* Creates a new zoological taxon name instance
}else if ( isZoologicalName && ! isBotanicalName && !isBacteriologicalName && !isCultivatedPlantName){
result = TaxonNameFactory.NewBacterialInstance(rank);
}else {
- result = TaxonNameBase.NewNonViralInstance(rank);
+ result = TaxonNameFactory.NewNonViralInstance(rank);
}
} else {
switch (code) {
import eu.etaxonomy.cdm.model.common.CdmBase;
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;
/**
* @author cmathew
public void testPropertyChange() {
CdmBase.setNewEntityListener(this);
- NonViralName<?> b = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
Annotation newAnnotation = Annotation.NewDefaultLanguageInstance("test");
b.addAnnotation(newAnnotation);
Assert.assertEquals(newAnnotation, lastPropValue);
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;
public class PropertyChangeTest implements PropertyChangeListener {
static Logger logger = Logger.getLogger(PropertyChangeTest.class);
@Test
public void testPropertyChange() {
- NonViralName<?> b = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> b = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
b.addPropertyChangeListener(this);
b.setGenusOrUninomial("Abies");
assertEquals(b.getGenusOrUninomial(), lastPropValue);
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
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
@Before\r
public void setUp() throws Exception {\r
\r
- abies = TaxonNameBase.NewNonViralInstance(Rank.GENUS(), null);\r
+ abies = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);\r
abies.setNameCache("Abies");\r
abies.setTitleCache("Abies", true);\r
Reference sec = ReferenceFactory.newArticle();\r
\r
abiesTaxon = Taxon.NewInstance(abies, sec);\r
\r
- abiesMill = TaxonNameBase.NewNonViralInstance(Rank.GENUS(), null);\r
+ abiesMill = TaxonNameFactory.NewNonViralInstance(Rank.GENUS(), null);\r
abiesMill.setNameCache("Abies");\r
abiesMill.setTitleCache("Abies Mill.", true);\r
abiesMillTaxon = Taxon.NewInstance(abiesMill, sec);\r
\r
- abiesAlba = TaxonNameBase.NewNonViralInstance(Rank.SPECIES(), null);\r
+ abiesAlba = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES(), null);\r
abiesAlba.setNameCache("Abies alba");\r
abiesAlba.setTitleCache("Abies alba", true);\r
\r
- abiesAlbaMichx = TaxonNameBase.NewNonViralInstance(Rank.SPECIES(), null);\r
+ abiesAlbaMichx = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES(), null);\r
abiesAlbaMichx.setNameCache("Abies alba");\r
abiesAlbaMichx.setTitleCache("Abies alba Michx.", true);\r
\r
- abiesAlbaMill = TaxonNameBase.NewNonViralInstance(Rank.SPECIES(), null);\r
+ abiesAlbaMill = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES(), null);\r
abiesAlbaMill.setNameCache("Abies alba");\r
abiesAlbaMill.setTitleCache("Abies alba Mill.", true);\r
\r
- abiesAutonym = TaxonNameBase.NewNonViralInstance(Rank.SECTION_BOTANY());\r
+ abiesAutonym = TaxonNameFactory.NewNonViralInstance(Rank.SECTION_BOTANY());\r
abiesAutonym.setGenusOrUninomial("Abies");\r
abiesAutonym.setInfraGenericEpithet("Abies");\r
\r
abiesAutonym.getNameCache();\r
abiesAutonymTaxon = Taxon.NewInstance(abiesAutonym, sec);\r
\r
- abiesBalsamea = TaxonNameBase.NewNonViralInstance(Rank.SECTION_BOTANY());\r
+ abiesBalsamea = TaxonNameFactory.NewNonViralInstance(Rank.SECTION_BOTANY());\r
abiesBalsamea.setGenusOrUninomial("Abies");\r
abiesBalsamea.setInfraGenericEpithet("Balsamea");\r
abiesBalsamea.getNameCache();\r
abiesBalsamea.setTitleCache("Abies sect. Balsamea L.", true);\r
abiesBalsameaTaxon = Taxon.NewInstance(abiesBalsamea, sec);\r
\r
- abiesAlbaxPinusBeta = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());\r
- pinusBeta = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());\r
+ abiesAlbaxPinusBeta = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ pinusBeta = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
pinusBeta.setGenusOrUninomial("Pinus");\r
pinusBeta.setSpecificEpithet("beta");\r
abiesAlbaxPinusBeta.setHybridFormula(true);\r
*/
@Test
public final void testNonViralNameRank() {
- NonViralName<?> nonViralName = TaxonNameBase.NewNonViralInstance(Rank.GENUS());
+ NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());
assertNotNull(nonViralName);
}
assertEquals(0, botanicalName1.getHybridParentRelations().size());
assertEquals(0, botanicalName1.getHybridChildRelations().size());
BotanicalName femaleParent = TaxonNameBase.NewBotanicalInstance(null);
- NonViralName<?> maleParent = TaxonNameBase.NewNonViralInstance(null);
+ NonViralName<?> maleParent = TaxonNameFactory.NewNonViralInstance(null);
ZoologicalName child = TaxonNameBase.NewZoologicalInstance(null);
botanicalName1.addHybridParent(femaleParent, HybridRelationshipType.FEMALE_PARENT(), null);
nonViralName1.setInfraSpecificEpithet("infrabus");
nonViralName1.setBinomHybrid(true);
- NonViralName<?> parent = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> parent2 = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> child = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> child2 = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> parent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> parent2 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> child = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> 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");
\r
@Test\r
public void testClone(){\r
- NonViralName taxonNameBase1 = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());\r
- NonViralName<?> genusName = TaxonNameBase.NewNonViralInstance(Rank.GENUS());\r
+ NonViralName taxonNameBase1 = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ NonViralName<?> genusName = TaxonNameFactory.NewNonViralInstance(Rank.GENUS());\r
Taxon taxonBase = Taxon.NewInstance(taxonNameBase1, null);\r
\r
//basionym & homonym\r
- NonViralName<?> basionym = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());\r
- NonViralName<?> earlierHomonym = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());\r
+ NonViralName<?> basionym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
+ NonViralName<?> earlierHomonym = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());\r
taxonNameBase1.addBasionym(basionym);\r
taxonNameBase1.addRelationshipToName(earlierHomonym, NameRelationshipType.LATER_HOMONYM(), "later homonym rule");\r
//status\r
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;
Assert.assertEquals(author.getNomenclaturalTitle(), speciesName.getAuthorshipCache());
Assert.assertEquals("Should be 'Abies alba L.'", "Abies alba L.", speciesName.getTitleCache());
- NonViralName<?> hybridName = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
- NonViralName<?> secondParent = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> hybridName = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> secondParent = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
secondParent.setTitleCache("Second parent Mill.", true);
hybridName.addHybridParent(speciesName, HybridRelationshipType.FIRST_PARENT(), null);
@Test
public void testGetInfraGenericNames(){
String author = "Anyauthor";
- NonViralName<?> nonViralName = TaxonNameBase.NewNonViralInstance(Rank.SUBGENUS());
+ NonViralName<?> nonViralName = TaxonNameFactory.NewNonViralInstance(Rank.SUBGENUS());
nonViralName.setGenusOrUninomial("Genus");
nonViralName.setInfraGenericEpithet("subgenus");
nonViralName.setAuthorshipCache(author);
import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;\r
import eu.etaxonomy.cdm.model.description.TaxonDescription;\r
import eu.etaxonomy.cdm.model.name.INonViralName;\r
-import eu.etaxonomy.cdm.model.name.TaxonNameBase;\r
+import eu.etaxonomy.cdm.model.name.TaxonNameFactory;\r
import eu.etaxonomy.cdm.model.taxon.Taxon;\r
\r
/**\r
feature3 = Feature.NewInstance("","Length of wings","");\r
feature4 = Feature.NewInstance("","Colour","");\r
\r
- INonViralName tn1 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn2 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn3 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn4 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn5 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn6 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn7 = TaxonNameBase.NewNonViralInstance(null);\r
- INonViralName tn8 = TaxonNameBase.NewNonViralInstance(null);\r
+ INonViralName tn1 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn2 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn3 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn4 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn5 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn6 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn7 = TaxonNameFactory.NewNonViralInstance(null);\r
+ INonViralName tn8 = TaxonNameFactory.NewNonViralInstance(null);\r
\r
taxon1 = Taxon.NewInstance(tn1, null);\r
taxon2 = Taxon.NewInstance(tn2, null);\r
import eu.etaxonomy.cdm.model.common.Language;
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.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.model.taxon.Taxon;
// to a taxon name with no name cache to begin with
Reference sec = ReferenceFactory.newDatabase();
referenceService.save(sec);
- Taxon taxon = Taxon.NewInstance(TaxonNameBase.NewNonViralInstance(Rank.SERIES()), sec);
+ Taxon taxon = Taxon.NewInstance(TaxonNameFactory.NewNonViralInstance(Rank.SERIES()), sec);
taxon.setTitleCache("Tax" + "CdmCacher", true);
taxonService.save(taxon);
NonViralName<?> nvn = (NonViralName<?>)taxon.getName();
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
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.taxon.Taxon;
import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
public void setUp() throws Exception {
// set up your test objects here
- INonViralName tnb = TaxonNameBase.NewNonViralInstance(null);
+ INonViralName tnb = TaxonNameFactory.NewNonViralInstance(null);
Taxon taxon = Taxon.NewInstance(tnb, null);
description = TaxonDescription.NewInstance(taxon);
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
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.reference.Reference;
import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
import eu.etaxonomy.cdm.model.taxon.Synonym;
//service = new TaxonServiceImpl();
//nameService = new NameServiceImpl();
- t1n = TaxonNameBase.NewNonViralInstance(null);
+ t1n = TaxonNameFactory.NewNonViralInstance(null);
t1 = Taxon.NewInstance(t1n, reference);
- t2n = TaxonNameBase.NewNonViralInstance(null);
+ t2n = TaxonNameFactory.NewNonViralInstance(null);
t2 = Taxon.NewInstance(t2n, reference);
- s1n = TaxonNameBase.NewNonViralInstance(null);
+ s1n = TaxonNameFactory.NewNonViralInstance(null);
s1 = Synonym.NewInstance(s1n, reference);
- s2n = TaxonNameBase.NewNonViralInstance(null);
+ s2n = TaxonNameFactory.NewNonViralInstance(null);
s2 = Synonym.NewInstance(s2n, reference);
// referencing
@Test
public final void testChangeSynonymWithMultipleSynonymsInHomotypicalGroupToAcceptedTaxon() {
t1.addSynonym(s1, heteroTypicSynonymType);
- TaxonNameBase<?,?> otherHeteroSynonymName = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> otherHeteroSynonymName = TaxonNameFactory.NewNonViralInstance(null);
t1.addHeterotypicSynonymName(otherHeteroSynonymName);
- TaxonNameBase<?,?> homotypicSynonymName = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> homotypicSynonymName = TaxonNameFactory.NewNonViralInstance(null);
Synonym homotypicSynonym = Synonym.NewInstance(homotypicSynonymName, t1.getSec());
t1.addHomotypicSynonym(homotypicSynonym);
t1.addSynonym(s1, heteroTypicSynonymType);
//s2 - heterotypic
- TaxonNameBase otherHeteroSynonymName = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase otherHeteroSynonymName = TaxonNameFactory.NewNonViralInstance(null);
Synonym s2 = Synonym.NewInstance(otherHeteroSynonymName, t1.getSec());
t1.addSynonym(s2, heteroTypicSynonymType);
- TaxonNameBase<?,?> otherHeteroSynonymNameB = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> otherHeteroSynonymNameB = TaxonNameFactory.NewNonViralInstance(null);
otherHeteroSynonymName.addBasionym(otherHeteroSynonymNameB);
Synonym s2b = Synonym.NewInstance(otherHeteroSynonymNameB, t1.getSec());
t1.addSynonym(s2b, heteroTypicSynonymType);
//homotypic
- TaxonNameBase<?,?> homotypicSynonymName = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> homotypicSynonymName = TaxonNameFactory.NewNonViralInstance(null);
Synonym homotypicSynonym = Synonym.NewInstance(homotypicSynonymName, t1.getSec());
t1.addHomotypicSynonym(homotypicSynonym);
t1.getName().addBasionym(homotypicSynonymName);
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.occurrence.DerivedUnit;
import eu.etaxonomy.cdm.model.occurrence.DeterminationEvent;
import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
Reference reference = ReferenceFactory.newGeneric();
String referenceDetail = "test";
- NonViralName<?> t1n = TaxonNameBase.NewNonViralInstance(null);
+ NonViralName<?> t1n = TaxonNameFactory.NewNonViralInstance(null);
Taxon t1 = Taxon.NewInstance(t1n, reference);
- NonViralName<?> t2n = TaxonNameBase.NewNonViralInstance(null);
+ NonViralName<?> t2n = TaxonNameFactory.NewNonViralInstance(null);
Taxon t2 = Taxon.NewInstance(t2n, reference);
- NonViralName<?> s1n = TaxonNameBase.NewNonViralInstance(null);
+ NonViralName<?> s1n = TaxonNameFactory.NewNonViralInstance(null);
Synonym s1 = Synonym.NewInstance(s1n, reference);
t1.addSynonym(s1, heteroTypicSynonymType);
service.saveOrUpdate(t1);
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;
public void testAppController() {
logger.info("Create name objects...");
- NonViralName<?> nvn = TaxonNameBase.NewNonViralInstance(Rank.SPECIES());
+ NonViralName<?> nvn = TaxonNameFactory.NewNonViralInstance(Rank.SPECIES());
BotanicalName bn = TaxonNameBase.NewBotanicalInstance(Rank.SUBSPECIES());
ZoologicalName zn = TaxonNameBase.NewZoologicalInstance(Rank.FAMILY());
appCtr = CdmApplicationController.NewInstance(dbSchemaValidation);
- TaxonNameBase<?,?> name = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> name = TaxonNameFactory.NewNonViralInstance(null);
name.setTitleCache("Abies alba", true);
- TaxonNameBase<?,?> name2 = TaxonNameBase.NewNonViralInstance(null);
+ TaxonNameBase<?,?> name2 = TaxonNameFactory.NewNonViralInstance(null);
name2.setTitleCache("Abies beta", true);
//appCtr.getNameService().saveTaxonName(name);