EDIT

		//Meikle

		if (source != null){

			data.addSource(OriginalSourceType.PrimaryTaxonomicSource, null, null, sourceRef, null, nameUsedInSource, null);

		}

		data.setUnit(meter);

	    List<AnnotatableEntity> homotypicalGroups;

		Reference citRef, sec;

		Taxon child1, child2, child21, root1T, root2T, freeT;

		Taxon childR2_1, childR2_2;

		TaxonNode child1Node, child2Node, child21Node, root1TNode, root2TNode, freeTNode;

					String newText = parseNewText(text);

					citation.removeText(language);

					citation.putText(language, newText);

					Set<DescriptionElementSource> sources = citation.getSources();

					if (sources.size() > 1){

	private void fillNameMaps(List<TaxonName> nameList, Map<String, TaxonName> nameMap, Map<String, TaxonName> duplicateMap) {

			String nameCache = name.getNameCache();

			if (nameMap.containsKey(nameCache)){

				duplicateMap.put(nameCache, name);

					//Designation

					SpecimenTypeDesignation designation = SpecimenTypeDesignation.NewInstance();

					SpecimenTypeDesignationStatus status = getSpecimenTypeDesignationStatusByKey(typeStatusFk);

					if (typeStatusFk != null && typeStatusFk.equals(39)){

	 * @param nameId

	 * @return

	 */

		if (state.getConfig().isDoTaxonNames()){

			result = taxonNameMap.get(String.valueOf(nameId));

		}else{

				String microCitation = null;

				String originalNameString = null;

				if (nameInSourceFk != null && nameUsedInSource == null){

					logger.warn("Name used in source (" + nameInSourceFk + ") was not found for common name " + commonNameId);

				}

			nameSpace = BerlinModelTaxonNameImport.NAMESPACE;

			cdmClass = TaxonName.class;

			idSet = nameIdSet;

			result.put(nameSpace, nameMap);

			//taxon map

				String category = CdmUtils.Nz(rs.getString("NameFactCategory"));

				String nameFact = CdmUtils.Nz(rs.getString("nameFact"));

				String nameFactRefFk = String.valueOf(nameFactRefFkObj);

				Reference citation = refMap.get(nameFactRefFk);

    				if (ref != null){

    					DescriptionElementSource originalSource = DescriptionElementSource.NewInstance(OriginalSourceType.PrimaryTaxonomicSource);

    					originalSource.setCitation(ref);

						taxonName = TaxonName.castAndDeproxy(getName(state, oldName, oldNameFk));

						if (taxonName != null){

    						originalSource.setNameUsedInSource(taxonName);

	 */

	boolean isFirstTimeNoNameByService = true;

	private INonViralName getName(BerlinModelImportState state, String oldName, Integer oldNameFk) {

		if (taxonName == null && oldName != null){

			if (isFirstTimeNoNameByService){

				logger.warn("oldName not checked against names in BerlinModel. Just take it as a string");

					uuid = rs.getString("UUID");

				}

				taxonName  = taxonNameMap.get(String.valueOf(nameFk));

				Reference reference = null;

					}

					//create TaxonName

					if (config.getNomenclaturalCode() != null){

						taxonName = config.getNomenclaturalCode().getNewTaxonNameInstance(rank);

						//check cultivar

				int relQualifierFk = rs.getInt("relNameQualifierFk");

				String notes = rs.getString("notes");

				Reference citation = null;

				//RejectedFlag false

				//PublishFlag xxx

				if (taxonNameBase != null){

					try{

	private boolean checkRank(List<TaxonName> list){

		List<TaxonName> errorNames = new ArrayList<>();

			if (name.getRank() == null) {

                ;

            }

		}

		if (errorNames.size() >0){

			System.out.println("The following names have no Rank:\n=======================");

				System.out.println("  " + name.toString());

				System.out.println("  " + name.getUuid());

				System.out.println("  " + name.getTitleCache());

			mapping.initialize(state);

			logger.info("save "+pluralString+" ...");

			int count = 0;

				doCount(count++, modCount, pluralString);

				success &= mapping.invoke(name);

				//TODO rank = null or rank < genus and genusOrUninomial != null

	private void handleBasionym(CaryoImportState state, ResultSet rs, Taxon taxon, String basioStr, Integer id) {

		if (StringUtils.isNotBlank(basioStr)){

			IBotanicalName name = taxon.getName();

			if (basionym.hasProblem()){

				logger.warn("Problem when parsing basionym ("+id+"): " +  basioStr);

			}

			return;

		}else{

			IBotanicalName name = taxon.getName();

			if ("not designated".equalsIgnoreCase(type)){

				desig.setNotDesignated(true);

			}else{

        for (String split : splits){

            split = replaceHomonIlleg(split);

            boolean isHomonym = split.matches(".*" + HOMONYM_MARKER);

            newName.setHomotypicalGroup(homotypicGroup);  //not really necessary as this is later set anyway

            if (newName.isProtectedTitleCache()){

                logger.warn(state.getCurrentLine() + ": homotypic name part could not be parsed: " + split);

                }

            }

            if (candidates.size() == 1){

                newName.addRelationshipToName(blockedName, NameRelationshipType.BLOCKING_NAME_FOR(), null);

                replacementNameCandidates.add(blockedName);

            }else{

            List<IBotanicalName> replacementNameCandidates) {

        String line = state.getCurrentLine() +": ";

        List<IBotanicalName> replacedCandidates = new ArrayList<>();

            IBotanicalName candidate = typifiedName;

            if (candidate.getBasionymAuthorship() == null){

                if (candidate.getStatus().isEmpty()){

            }

        }

        if (replacedCandidates.size() == 1){

            for (IBotanicalName replacementName : replacementNameCandidates){

                replacementName.addReplacedSynonym(replacedSynonym, null, null, null);

            }

    private void createBasionymRelationIfPossible(CubaImportState state, IBotanicalName name1,

            IBotanicalName name2,

            boolean name2isHomonym, boolean onlyIfNotYetExists) {

        //exactly one name must have a basionym author

        if (name1.getBasionymAuthorship() == null && name2.getBasionymAuthorship() == null

                || name1.getBasionymAuthorship() != null && name2.getBasionymAuthorship() != null){

                        logger.warn("Parent taxon " + parentTaxonFk + " not found for taxon " + id );

                    }else{

                        TaxonBase<?> child = state.getRelatedObject(TAXON_NAMESPACE, String.valueOf(id), TaxonBase.class);

//                        handleMissingNameParts(CdmBase.deproxy(childName, TaxonName.class), CdmBase.deproxy(parentName, NonViralName.class));

	private void addNameDescription(GlobisImportState state, IZoologicalName name, UUID featureUuid,

			String citedTypeLocality, String featureLabel) {

		Feature feature = getFeature(state, featureUuid,featureLabel,featureLabel, null, null);

	}

	private Synonym getSynonym(GlobisImportState state, ResultSet rs, Integer specTaxId) throws SQLException {

		Synonym synonym = Synonym.NewInstance(name, state.getTransactionalSourceReference());

        Classification classification = getClassificationService().load(state.getConfig().getClassificationUuid());

        TaxonNode plantae = classification.getChildNodes().iterator().next();

        name.setTitleCache("Excluded", true);

        Taxon taxon = Taxon.NewInstance(name, getSecReference(state));

        excludedFamilyNode = plantae.addChildTaxon(taxon, getSourceCitation(state), null);

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

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;

import eu.etaxonomy.cdm.model.taxon.Taxon;

    }

            String famStr) {

        famStr = famStr.substring(0,1).toUpperCase() + famStr.substring(1).toLowerCase();

        name.setGenusOrUninomial(famStr);

        name.addSource(makeOriginalSource(state));

        if (misappliedNecAuthor != null){

            nvn.setAuthorshipCache(misappliedNecAuthor);

        }

        if (hasStatus){

            try {

     * @param parsedSynStr

     */

    private void handleSynonymNon(SimpleExcelTaxonImportState<CONFIG> state,

        String[] splits = nonPart.split(" nec ");

        for (String split : splits){

            split = split.trim();

//            Saponaria illyrica Ard.

//            S. columnae Aurnier

//            S. columnae Aurnier nec (Rchb. f.) H. Fleischm.

//            T. glaucescens Rchb.

            if (split.matches("(Saponaria illyrica Ard.|Crepis nemausensis Gouan|S. columnae Aurnier|T. glaucescens Rchb.|Linaria stricta Guss.)"

                    + "")){

                if (split.startsWith("S.")){

     * @param line

     * @param name

     */

        if (name.getTaxonBases().size()==2){

            Iterator<TaxonBase> it = name.getTaxonBases().iterator();

            Taxon taxon1 = getAccepted(it.next());

			}

			if(elWissName.getAttributeValue(BfnXmlConstants.ATT_BEREICH, bfnNamespace).equalsIgnoreCase("wissName")){

				try{

					if(nameBase.isProtectedTitleCache() == true){

						logger.warn("Taxon " + nameBase.getTitleCache());

					}

				}

				if(elSynDetail.getAttributeValue(BfnXmlConstants.ATT_BEREICH).equalsIgnoreCase("wissName")){

					try{

						//TODO find best matching Taxa

						Synonym synonym = Synonym.NewInstance(nameBase, state.getCurrentMicroRef());

	 * @return

	 * @throws UnknownCdmTypeException

	 */

			throws UnknownCdmTypeException {

		String strScientificName = elWissName.getTextNormalize();

		/**

			strScientificName = StringUtils.remove(strScientificName, strSupplement);

		}

		NonViralNameParserImpl parser = NonViralNameParserImpl.NewInstance();

		if(nonViralName.hasProblem()){

			for(ParserProblem p:nonViralName.getParsingProblems()){

				logger.warn(++parsingProblemCounter + " " +nonViralName.getTitleCache() +" "+p.toString());