EDIT

import eu.etaxonomy.cdm.io.cuba.CubaTransformer;

//    static final ICdmDataSource cdmDestination = CdmDestinations.localH2();

    static final ICdmDataSource cdmDestination = CdmDestinations.cdm_cuba_production();

		Feature featurAltFam = (Feature)service.find(CubaTransformer.uuidAlternativeFamily);

		newNode = FeatureNode.NewInstance(featurAltFam);

		root.addChild(newNode);

	    Feature featurAltFam2 = (Feature)service.find(CubaTransformer.uuidAlternativeFamily2);

	    newNode = FeatureNode.NewInstance(featurAltFam2);

	    root.addChild(newNode);

import java.util.HashSet;

import eu.etaxonomy.cdm.model.common.OriginalSourceType;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.TaxonInteraction;

import eu.etaxonomy.cdm.model.description.TextData;

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

    private  static List<String> expectedKeys= Arrays.asList(new String[]{

            "Fam. default","Fam. FRC","Fam. A&S","Fam. FC",

            "Taxón","(Notas)","Syn.","End","Ind","Ind? D","Nat","Dud P","Adv","Cult C","CuW","PR PR*","Art","Hab(*)","May","Mat","IJ","CuC","VC","Ci","SS","CA","Cam","LT","CuE","Gr","Ho","SC","Gu","Esp","Ja","PR","Men","Bah","Cay","AmN","AmC","AmS","VM"});

            }else if(endemicStr.equals("?")){

                UUID endemicDoubtfulUuid = state.getTransformer().getPresenceTermUuid("?E");

                PresenceAbsenceTerm endemicState = getPresenceTerm(state, endemicDoubtfulUuid, null, null, null, false);

                result.add(endemicState);

                checkAbsentHighestState(highestStatus, line, "endemic", false);

            +"((\\sFC(\\-S)?(\\s&\\sA&S)?)|(\\sA&S)|\\sSagra|\\sCombs|\\sBritton|\\sGriseb\\.|\\sWright"

            + "|\\sHammer|\\sEngl\\.||\\sMaza|\\sMiers|\\sRoig|\\sBorhidi|\\sFRC|\\sCoL"

            + "|\\sAckerman|\\sMújica|\\sDíaz|\\sUrb\\.)?(\\s+p\\.\\s*p\\.)?";

    private static final String sphalmRegExStr = "“(.*{5,})”\\s+((FC-S|A&S)\\s)?sphalm\\.(\\s(FC(-S)?|A&S|inval\\.))?";

    private static final String nomInvalRegExStr = "“(.*{5,})”\\s+nom\\.\\s+inval\\.(\\s(West|Moldenke|FC|Jacq.))?";

    private static final Pattern sphalmRegEx = Pattern.compile(sphalmRegExStr);

        Matcher sphalmMatcher = sphalmRegEx.matcher(synonymStr);

            String afterInval = nomInvalMatcher.group(2);

            if (StringUtils.isNotBlank(afterInval)){

                logger.warn(state.getCurrentLine() + ": After inval to be implemented: " + afterInval);

            }

        }else if (sphalmMatcher.matches()){

            String firstPart = sphalmMatcher.group(1);

            String sphalmPart = synonymStr.replace(firstPart, "").replace("“","").replace("”","").trim();

            BotanicalName name = (BotanicalName)nameParser.parseSimpleName(firstPart, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

//            NomenclaturalStatus status = NomenclaturalStatus.NewInstance( NomenclaturalStatusType.INVALID());

//            name.addStatus(status);

            SynonymRelationship sr = state.getCurrentTaxon().addSynonymName(name, SynonymRelationshipType.SYNONYM_OF());

            sr.getSynonym().setAppendedPhrase(sphalmPart);

            sr.getSynonym().setSec(null);

            firstPart = replaceHomonIlleg(firstPart);

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

            BotanicalName synName = makeName(firstPart);

                logger.warn(line + " heterotypic base synonym could not be parsed correctly:" + firstPart);

            split = replaceHomonIlleg(split);

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

            BotanicalName newName = makeName(split);

        makeHomonyms(homonyms, homonymPart, state, currentBasionym);

    }

    /**

     * @param split

     * @return

     */

    private String replaceHomonIlleg(String split) {

        String result = split.trim().replace("homon. illeg.", "nom. illeg. homon.").trim();

        return result;

     * @param currentBasionym

    private void makeHomonyms(List<BotanicalName> homonyms, String homonymPartOrig, CubaImportState state,

            BotanicalName currentBasionym) {

        String homonymPart = homonymPartOrig == null ? "" : homonymPartOrig.trim();

            if(homonyms.size() == 0 && splits.length >= 1){

                handleSimpleBlockingNames(splits, state, currentBasionym);

            }else{

                logger.warn(line + "Number of homonyms (" + homonyms.size() + ") and homonymParts ("+splits.length+") does not match");

            }

            BotanicalName newName = makeName(split);

//            BotanicalName newName = (BotanicalName)nameParser.parseReferencedName(split, state.getConfig().getNomenclaturalCode(), Rank.SPECIES());

    /**

     * @param homonymPart

     * @param state

     * @param currentBasionym

     */

    private void handleSimpleBlockingNames(String[] splitsi, CubaImportState state,

            BotanicalName currentBasionym) {

        for (String spliti : splitsi){

            String split = spliti.replaceAll("^non\\s+", "");

            BotanicalName newName = makeName(split);

            if (newName.isProtectedTitleCache()){

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

            }

            Set<BotanicalName> typifiedNames = (Set)currentBasionym.getHomotypicalGroup().getTypifiedNames();

            Set<BotanicalName> candidates = new HashSet<>();

            for (BotanicalName name : typifiedNames){

                if (name.getGenusOrUninomial() != null && name.getGenusOrUninomial().equals(newName.getGenusOrUninomial())){

                    if (name.getStatus().isEmpty() || ! name.getStatus().iterator().next().getType().equals(NomenclaturalStatusType.ILLEGITIMATE())){

                        candidates.add(name);

                    }

                }

            }

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

                newName.addRelationshipToName(candidates.iterator().next(), NameRelationshipType.BLOCKING_NAME_FOR(), null);

            }else{

                logger.warn(state.getCurrentLine() + ": Blocking name could not be handled. " + candidates.size() + " candidates.");

            }

        }

    }

        BotanicalName botanicalName = makeName(taxonStr);

    private final String orthVarRegExStr = "[A-Z][a-z]+\\s[a-z]+\\s(\\(‘([a-z]){3,}’\\))\\s(\\([A-Z][a-z]+\\.?\\)\\s)?[A-Z][a-zó]+\\.?";

    private final Pattern orthVarRegEx = Pattern.compile(orthVarRegExStr);

    /**

     * @param taxonStr

     * @return

     */

    private BotanicalName makeName(String nameStrOrig) {

        //normalize

        String nameStr = normalizeStatus(nameStrOrig);

        //orthVar

        Matcher orthVarMatcher = orthVarRegEx.matcher(nameStr);

        String orthVar = null;

        if (orthVarMatcher.matches()) {

            orthVar = orthVarMatcher.group(1);

            nameStr = nameStr.replace(" " + orthVar, "").trim().replaceAll("\\s{2,}", " ");

            orthVar = orthVar.substring(2, orthVar.length() - 2);

        }

        BotanicalName result = (BotanicalName)nameParser.parseReferencedName(nameStr, nc, Rank.SPECIES());

        if (orthVar != null){

            BotanicalName orthVarName = (BotanicalName)result.clone();

            //TODO

            Reference<?> citation = null;

            orthVarName.addRelationshipToName(result, NameRelationshipType.ORTHOGRAPHIC_VARIANT(), citation, null, null);

            orthVarName.setSpecificEpithet(orthVar);

        }

        return result;

    }

            "nom. rej.","nom. cons. prop.","nom. altern.","nom. confus.","nom. dub.", "nom. nud."};

    private String normalizeStatus(String nameStr) {

        if (nameStr == null){

        String result = nameStr.replaceAll(HOMONYM_MARKER, "").trim();

            if (result.endsWith(nomStatusStr)){

                result = result.replace(nomStatusStr, "," + nomStatusStr);

        result = result.replaceAll(DOUBTFUL_MARKER, "").trim();

        result = result.replace("[taxon]", "[infraspec.]");

        return result;

        String familyStr = getValue(record, "Fam. default");

            BotanicalName name = state.getFamilyName(familyStr);

            if (name == null){

                name = BotanicalName.NewInstance(Rank.FAMILY());

                name.setGenusOrUninomial(familyStr);

                state.putFamilyName(familyStr, name);

            }

    /**

     * @param state

     * @param taxon

     * @param famStr

     * @param famRef

     * @return

     */

    private Taxon makeAlternativeFamilyTaxon(CubaImportState state, String famStr, Reference<?> famRef) {

        String key = famRef.getTitle() + ":"+ famStr;

        Taxon family = state.getHigherTaxon(key);

        if (family == null){

            BotanicalName name = state.getFamilyName(famStr);

            if (name == null){

                name = BotanicalName.NewInstance(Rank.FAMILY());

                name.setGenusOrUninomial(famStr);

                state.putFamilyName(famStr, name);

            }

            family = Taxon.NewInstance(name, famRef);

            state.putHigherTaxon(key, family);

        }

        return family;

    }

        if (record.get("Fam. default") == null && keys.size() == 2 && record.get("Syn.") == null && record.get("Nat") != null && record.get("Adv") != null){

        //Fam. ALT

        makeAlternativeFamilies(record, state, familyTaxon, taxon);

//      "Esp","Ja","PR","Men","Bah","Cay",

//      "AmN","AmC","AmS","VM"});

        makeOtherAreasDistribution(record, state);

     * @param familyTaxon

     * @param taxon

     */

    private void makeAlternativeFamilies(HashMap<String, String> record,

            CubaImportState state,

            TaxonNode familyTaxon,

            Taxon taxon) {

        String famFRC = record.get("Fam. FRC");

        String famAS = record.get("Fam. A&S");

        String famFC = record.get("Fam. FC");

        Reference<?> refFRC = makeReference(state, CubaTransformer.uuidRefFRC);

        Reference<?> refAS = makeReference(state, CubaTransformer.uuidRefAS);

        Reference<?> refFC = makeReference(state, CubaTransformer.uuidRefFC);

        makeSingleAlternativeFamily(state, taxon, famFRC, refFRC);

        makeSingleAlternativeFamily(state, taxon, famAS, refAS);

        makeSingleAlternativeFamily(state, taxon, famFC, refFC);

    }

    /**

     * @param state

     * @param uuidreffrc

     * @return

     */

    private Reference<?> makeReference(CubaImportState state, UUID uuidRef) {

        Reference<?> ref = state.getReference(uuidRef);

        if (ref == null){

            ref = getReferenceService().find(uuidRef);

            state.putReference(uuidRef, ref);

        }

        return ref;

    }

    /**

     * @param state

     * @param taxon

     * @param famString

     * @param famRef

     */

    private void makeSingleAlternativeFamily(CubaImportState state, Taxon taxon, String famStr, Reference<?> famRef) {

        if (isBlank(famStr)){

            return;

        }

        TaxonDescription desc = getTaxonDescription(taxon, false, true);

        UUID altFamUuid1;

        UUID altFamUuid2;

        try {

            altFamUuid1 = state.getTransformer().getFeatureUuid("Alt.Fam.");

            altFamUuid2 = state.getTransformer().getFeatureUuid("Alt.Fam.2");

        } catch (UndefinedTransformerMethodException e) {

            throw new RuntimeException(e);

        }

        Taxon famTaxon = makeAlternativeFamilyTaxon(state, famStr, famRef);

        //TextData

        Feature feature1 = getFeature(state, altFamUuid1, "Family in other floras", "Family in other floras", "Other floras", null);

//        TextData textData = TextData.NewInstance(feature1, famStr, Language.DEFAULT(), null);

        TextData textData = TextData.NewInstance(feature1, null, Language.DEFAULT(), null);

        textData.addSource(OriginalSourceType.PrimaryTaxonomicSource, null,null, famRef, null, famTaxon.getName(),null);

        desc.addElement(textData);

        //TaxonInteraction

        Feature feature2 = getFeature(state, altFamUuid2, "Family in other floras(2)", "Family in other floras(2)", "Other floras(2)", null);

        feature2.setSupportsTaxonInteraction(true);

        TaxonInteraction taxInteract = TaxonInteraction.NewInstance(feature2);

        taxInteract.setTaxon2(famTaxon);

        taxInteract.addSource(OriginalSourceType.PrimaryTaxonomicSource, null,null, famRef, null);

        desc.addElement(taxInteract);

        //Concept Relation

        famTaxon.addTaxonRelation(taxon, TaxonRelationshipType.INCLUDES(), taxon.getSec(), null);

    }

    /**

     * @param record

     * @param state

                status = state.getTransformer().getPresenceTermByKey("--");

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

	private final Map<String, BotanicalName> familyNameMap = new HashMap<String, BotanicalName>();

    //family names

    public BotanicalName getFamilyName(String familyStr) {

        return familyNameMap.get(familyStr);

    }

    public void putFamilyName(String familyStr, BotanicalName name) {

        familyNameMap.put(familyStr, name);

    }

    Map<UUID, Reference<?>> refMap = new HashMap<UUID, Reference<?>>();

    //reference

    public Reference<?> getReference(UUID uuidRef) {

        return refMap.get(uuidRef);

    }

    public void putReference(UUID uuidRef, Reference<?> ref) {

        refMap.put(uuidRef, ref);

    }

    //references

    public static final UUID uuidRefFRC = UUID.fromString("c1caf6a2-5083-4f44-8f97-9abe23a84cd8");

    public static final UUID uuidRefAS = UUID.fromString("1f15291a-b4c5-4e15-960f-d0145a250539");

    public static final UUID uuidRefFC = UUID.fromString("c5a0bfb8-85b2-422d-babe-423aa2e24c35");

    //featureUUID

    public static final UUID uuidAlternativeFamily = UUID.fromString("a005f8a1-6377-4641-a826-185f67136860");

    public static final UUID uuidAlternativeFamily2 = UUID.fromString("ff15b54a-6785-4ba0-acb6-8fb2eab80a6a");

    public static final UUID doubtfullyEndemicUuid = UUID.fromString("5f954f08-267a-4928-b073-12328f74c187");

        }else if (key.equalsIgnoreCase("?E")){return doubtfullyEndemicUuid;

        }else if (key.equalsIgnoreCase("--")){return PresenceAbsenceTerm.REPORTED_IN_ERROR();

    @Override

    public UUID getFeatureUuid(String key) throws UndefinedTransformerMethodException {

        if (key == null){

            return null;

        }else if (key.equalsIgnoreCase("Alt.Fam.")){

            return uuidAlternativeFamily;

        }else if (key.equalsIgnoreCase("Alt.Fam.2")){

            return uuidAlternativeFamily2;

        }else{

            throw new RuntimeException("feature not defined: " + key);

        }

    }

import java.net.URI;

import eu.etaxonomy.cdm.common.DOI;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.strategy.parser.TimePeriodParser;

            makeAlternativeFloras(state);

    /**

     * @param state

     */

    private void makeAlternativeFloras(CubaImportState state) {

        //FRC

        Reference<?> refFRC = ReferenceFactory.newBook();

        refFRC.setUuid(CubaTransformer.uuidRefFRC);

        refFRC.setTitle("Flora de la República de Cuba");

        getReferenceService().save(refFRC);

        //A&S

        Reference<?> refAS = ReferenceFactory.newArticle();

        refAS.setUuid(CubaTransformer.uuidRefAS);

        refAS.setTitle("Catalogue of seed plants of the West Indies");

        Person acevedo = Person.NewInstance();

        acevedo.setFirstname("Pedro");

        acevedo.setLastname("Acevedo-Rodríguez");

        Person strong = Person.NewInstance();

        strong.setFirstname("Mark T.");

        strong.setLastname("Strong");

        Team asTeam = Team.NewInstance();

        asTeam.addTeamMember(acevedo);

        asTeam.addTeamMember(strong);

        refAS.setAuthorship(asTeam);

        refAS.setDatePublished(TimePeriodParser.parseString("2012-01-01"));

        refAS.setVolume("98");

        refAS.setPages("i-xxv, 1-1192");

        refAS.setIssn("0081-024X");

        refAS.setDoi(DOI.fromString("10.5479/si.0081024X.98.1"));

        refAS.setUri(URI.create("http://hdl.handle.net/10088/17551"));

        String abstracct = "The catalogue enumerates all taxa of Gymnosperms, Dicotyledons, and Monocotyledons occurring in the West Indies archipelago excluding the islands off the coast of Venezuela (Netherlands Antilles, Venezuelan Antilles, Tobago, and Trinidad). For each accepted taxon, nomenclature (including synonyms described from the West Indies and their references to publication), distribution in the West Indies (including endemic, native, or exotic status), common names, and a numerical listing of literature records are given. Type specimen citations are provided for accepted names and synonyms of Cyperaceae, Sapindaceae, and some selected genera in several families including the Apocynaceae (Plumeria), Aquifoliaceae (Ilex), and Santalaceae (Dendrophthora). More than 30,000 names were treated comprising 208 families, 2,033 genera, and 12,279 taxa, which includes exotic and commonly cultivated plants. The total number of indigenous taxa was approximately 10,470 of which 71% (7,446 taxa) are endemic to the archipelago or part of it. Fifteen new names, 37 combinations, and 7 lectotypifications are validated. A searchable website of this catalogue, maintained and continuously updated at the Smithsonian Institution, is available at http://botany.si.edu/antilles/WestIndies/.";

        refAS.setReferenceAbstract(abstracct);

        Reference<?> refASIn = ReferenceFactory.newJournal();

        refAS.setInReference(refASIn);

        getReferenceService().save(refAS);

        //FC

        Reference<?> refFC = ReferenceFactory.newBook();

        refFC.setUuid(CubaTransformer.uuidRefFC);

        refFC.setTitle("Flora de Cuba");

        Person leon = Person.NewTitledInstance("León");

        Person alain = Person.NewTitledInstance("Alain");

        Team fcTeam = Team.NewInstance();

        fcTeam.addTeamMember(leon);

        fcTeam.addTeamMember(alain);

        refAS.setAuthorship(fcTeam);

        getReferenceService().save(refFC);

    }

        //doubtfully endemic

        UUID doubtfullyEndemicUuid = transformer.getPresenceTermUuid("?E");

        this.getPresenceTerm(state, doubtfullyEndemicUuid, "doubtfully endemic", "doubtfully endemic", "?E", false);

        this.getPresenceTerm(state, indigenousUuid, "indigenous", "Indigenous", "+", false);

        this.getPresenceTerm(state, indigenousDoubtfulUuid, "indigenous, doubtfully present", "indigenous, doubtfully present", "?", false);

        this.getPresenceTerm(state, nonNativeDoubtfulNaturalizedUuid, "non-native and doubtfully naturalised", "non-native and doubtfully naturalised", "P", false);

        this.getPresenceTerm(state, casualUuid, "adventive (casual) alien", "adventive (casual) alien", "A", false);

        getPresenceTerm(state, occasionallyCultivatedUuid, label, label, abbrev, PRESENT, cubaStatusVocabualary);

        this.getPresenceTerm(state, doubtfullyIndigenousUuid, "indigenous?", "Indigenous?", "D", false);

        this.getPresenceTerm(state, doubtfullyIndigenousDoubtfulUuid, "?indigenous?", "doubfully indigenous, (und) doubtfully present", "??", false);

        this.getPresenceTerm(state, doubtfullyNaturalisedUuid, "?non-native and doubtfully naturalised", "non-native and doubtfully naturalised, doubtfully present", "?N", false);

        this.getPresenceTerm(state, doubtfullyNonNativeUuid, "?adventive (casual) alien ", "adventive (casual) alien, doubtfully present", "?P", false);

        this.getPresenceTerm(state, endemicErrorUuid, "endemic, reported in error", "endemic, reported in error", "-E", isAbsent);

        this.getPresenceTerm(state, naturalizedErrorUuid, "naturalised, reported in error", "naturalised, reported in error", "-N", isAbsent);

        this.getPresenceTerm(state, nonNativeErrorUuid, "non-native and doubtfully naturalised, reported in error", "non-native and doubtfully naturalised, reported in error", "-P", isAbsent);

        this.getPresenceTerm(state, casualErrorUuid, "adventive alien , reported in error", "adventive alien , reported in error", "-A", isAbsent);