EDIT

    private MyName currentMyName;

    private String followingText;  //text element immediately following a tax:name in tax:nomenclature TODO move do state

    private String usedFollowingTextPrefix; //the part of the following text which has been used during taxon name creation

     * @param configState

     */

    public TaxonXTreatmentExtractor(NomenclaturalCode nomenclaturalCode, Classification classification, TaxonXImport importer,

        this.nomenclaturalCode=nomenclaturalCode;

        this.classification = classification;

        this.importer=importer;

     */

    @SuppressWarnings({ "rawtypes", "unused" })

        List<TaxonNameBase> namesToSave = new ArrayList<TaxonNameBase>();

        NodeList children = treatmentnode.getChildNodes();

        Taxon acceptedTaxon =null;

        buildFeatureTree();

    }

			List<TaxonNameBase> namesToSave, Node child, Taxon acceptedTaxon) {

		Taxon defaultTaxon =null;

     * @param refMods: the current reference extracted from the MODS

     */

    /*   @SuppressWarnings("rawtypes")

        acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);

        NodeList children = keys.getChildNodes();

     * @return Taxon object built

     */

    @SuppressWarnings({ "rawtypes", "unused" })

        //        logger.info("getTaxonFromXML");

        //        logger.info("acceptedTaxon: "+acceptedTaxon);

        logger.info("getTaxonNameBaseFromXML");

    //     * @return Taxon

    //     */

    //    @SuppressWarnings({ "unused", "rawtypes" })

    //        Taxon t = new Taxon(taxonNameBase,null );

    //        if (!configState.getConfig().doKeepOriginalSecundum() || (t.getSec() == null)) {

    //            t.setSec(configState.getConfig().getSecundum());

    //        return t;

    //    }

            String featureName) {

        //        System.out.println("extractDescriptionWithReference !");

        logger.info("extractDescriptionWithReference");

            }

        }

        if(!r.isEmpty()) {

            currentref.setTitleCache(r, true);

        } else {

     * @param refMods: the current reference extracted from the MODS

     */

    @SuppressWarnings("rawtypes")

        logger.info("extractDistribution");

        //        logger.info("acceptedTaxon: "+acceptedTaxon);

        NodeList children = distribution.getChildNodes();

     * @param currentFeature

     * @param k

     */

            Feature currentFeature, int k) {

        //logger.info("handleTextData");

        TextData textData = TextData.NewInstance();

     * @param td

     * @param soo

     */

        logger.info("handleAssociation");

        String descr=soo.getDescr();

        DerivedUnit derivedUnitBase = soo.getDerivedUnitBase();

     * @param feature

     * @return

     */

            Feature feature) {

        logger.info("createIndividualAssociation");

        IndividualsAssociation indAssociation = IndividualsAssociation.NewInstance();

     * @param paragraph

     */

    @SuppressWarnings("rawtypes")

            int i, Node paragraph) {

        //logger.info("extractInLine");

        String inLine=getInlineTextForName(nametosave, refMods, paragraph);

     * @param refMods: the current reference extracted from the MODS

     */

    @SuppressWarnings("rawtypes")

        logger.info("EXTRACTMATERIALS");

        //        logger.info("acceptedTaxon: "+acceptedTaxon);

        NodeList children = materials.getChildNodes();

     * @param rawAssociation

     * @param k

     */

            String rawAssociation) {

        logger.info("handleDerivedUnitFacadeAndBase");

        String descr;

     * @param acceptedTaxon: the current accepted Taxon

     * @param refMods: the current reference extracted from the MODS

     */

        logger.info("extractMaterialsDirect");

        //        logger.info("acceptedTaxon: "+acceptedTaxon);

        String descr="";

     */

    @SuppressWarnings({ "rawtypes"})

    private String extractSpecificFeature(Node description, Taxon acceptedTaxon, Taxon defaultTaxon,

        logger.info("extractSpecificFeature "+featureName);

        //        System.out.println("GRUUUUuu");

        NodeList children = description.getChildNodes();

     */

    @SuppressWarnings({ "unused", "rawtypes" })

    private String extractSpecificFeatureNotStructured(Node description, Taxon acceptedTaxon, Taxon defaultTaxon,

        logger.info("extractSpecificFeatureNotStructured " + featureName);

        NodeList children = description.getChildNodes();

        NodeList insideNodes ;

     * @param j

     */

    @SuppressWarnings({ "rawtypes" })

        if (true){

        	NodeList children = insideNode.getChildNodes();

        	String result = "";

     * @return a list of description (text)

     */

    @SuppressWarnings({ "unused", "rawtypes" })

        logger.info("parseParagraph "+feature.toString());

        List<String> fullDescription=  new ArrayList<String>();

        //        String localdescr;

                        if (ref.endsWith(";")  && ((ref.length())>1)) {

                            ref=ref.substring(0, ref.length()-1)+".";

                        }

                        reference.setTitleCache(ref, true);

                        blabla.add(reference.getTitleCache());

                        nodeKnown=true;

     * @param feature: the feature to link the data with

     */

    @SuppressWarnings("rawtypes")

        logger.info("EXTRACT FEATURE "+feature.toString());

        acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);

        List<String> fullDescription= parseParagraph( namesToSave, acceptedTaxon, refMods, description,feature);

     * @param currentFeature: the feature name

     * @return

     */

        logger.info("setParticularDescription " + currentFeature.getTitleCache()+", \n blabla : "+descr);

        //remove redundant feature title

     * @param currentFeature

     * @return

     */

        //logger.info("createTextData");

        TextData textData = TextData.NewInstance();

        textData.setFeature(currentFeature);

     * @param currentFeature: the feature name

     * @return

     */

        //        System.out.println("setParticularDescriptionSPecial "+currentFeature);

        //        logger.info("acceptedTaxon: "+acceptedTaxon);

        logger.info("setParticularDescription");

     * @param refMods: the current reference extracted from the MODS

     */

    @SuppressWarnings({ "rawtypes" })

        logger.info("extractSynonyms");

        //System.out.println("extractSynonyms for: "+acceptedTaxon);

        Taxon ttmp = (Taxon) importer.getTaxonService().find(acceptedTaxon.getUuid());

     * handle cases where the bibref are inside <p> and outside

     */

    @SuppressWarnings({ "rawtypes" })

        logger.info("extractReferences");

        acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);

     * handle cases where the bibref are inside <p> and outside

     */

    @SuppressWarnings("rawtypes")

            Taxon acceptedTaxon) {

        logger.info("extractReferenceRawText");

        String refString="";

                }

                if (nameOrRefOrOther==1){

                    re.setTitleCache(fullLineRefName, true);

                    /* TaxonNameBase nameTBF = parser.parseFullName(currentMyName.getName(), nomenclaturalCode, currentMyName.getRank());

            if(!currentMyName.getName().isEmpty()){

                //logger.info("acceptedTaxon and name: *"+acceptedTaxon.getTitleCache()+"*, *"+currentMyName.getName()+"*");

                if (acceptedTaxon.getTitleCache().split("sec")[0].trim().equalsIgnoreCase(currentMyName.getName().trim())){

                    refS.setTitleCache(refString, true);

                    //                            TaxonDescription td =importer.getTaxonDescription(acceptedTaxon, false, true);

                    //                            acceptedTaxon.addDescription(td);

        //logger.info("search reference for LSID");

        //  if ((id.indexOf("lsid")<0) || !lsidok){

        //ADD ORIGINAL SOURCE ID EVEN IF LSID

        Pager<Reference> references = importer.getReferenceService().findByTitle(Reference.class, source, MatchMode.EXACT, null, 1, null, null, null);

        if( references !=null && references.getCount()>0){

            re=references.getRecords().get(0);

     * @return

     */

    @SuppressWarnings({ "rawtypes" })

        refMods=CdmBase.deproxy(refMods, Reference.class);

        logger.info("extractNomenclature");

                                    //System.out.println("NEW ACCEPTED HERE "+nameToBeFilled);

                                }

                                else {

                                    //System.out.println("NEW ACCEPTED HERE2 "+nameToBeFilled);

                                }

     * @param ref: the current reference extracted from the MODS

     * @return the parent for the current accepted taxon

     */

        acceptedTaxon = CdmBase.deproxy(acceptedTaxon, Taxon.class);

        List<Rank> rankList = new ArrayList<Rank>();

     */

        //System.out.println("extractScientificNameSynonym");

        logger.info("extractScientificNameSynonym");

        String[] rankListToPrint_tmp ={"dwc:genus","dwc:specificepithet","dwc:species","dwc:subspecies", "dwc:infraspecificepithet","dwc:scientificnameauthorship"};

     * @return a list of possible names

     */

    @SuppressWarnings({"rawtypes" })

        logger.info("extractScientificName");

        String[] rankListToPrintLowerCase_tmp ={"dwc:genus","dwc:specificepithet","dwc:species","dwc:subspecies", "dwc:infraspecificepithet","dwc:scientificnameauthorship"};

     * I created this switch for old

     * for Spiders the new version is preferred

     */

        logger.info("createSynonym");

        NonViralName<?> nameToBeFilled = this.getNonViralNameAccNomenclature();

        	}else if (atomisedMap.get("dwc:subspecies") != null){

        		nameToBeFilled.setInfraSpecificEpithet(atomisedMap.get("dwc:subspecies"));

        	}

            if(!state2.getConfig().doKeepOriginalSecundum()){

                sec = state2.getConfig().getSecundum();

            }

        NonViralName<?> taxonNameBase;

        Taxon family,subfamily,tribe,subtribe,genus,subgenus,species,subspecies, variety,form;

        NonViralName<?> familyName, subfamilyName, tribeName,subtribeName,genusName,subgenusName,speciesName,subspeciesName;

            this.isSynonym = isSynonym;

        }

            refMods=re;

        }

     * @param similarityAuthor

     * @return

     */

            Taxon bestMatchingTaxon, double similarityAuthor) {

        //logger.info("compareAndCheckTaxon");

        boolean insertAsExisting;

     * @param taxonNameBase

     */

    @SuppressWarnings("rawtypes")

        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();

     * @param myName

     * @param parser

     */

        System.out.println("handleSubfamilyHierarchy");

        String parentStr = myName.getFamilyStr();

        Rank r = Rank.FAMILY();

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSubfamilyStr();

        Rank r = Rank.SUBFAMILY();

        if (parentStr == null){

     * @param myName

     * @param parser

     */

        String parentStr = myName.getTribeStr();

        Rank r = Rank.TRIBE();

        if (parentStr == null){

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSubtribeStr();

        Rank r = Rank.SUBTRIBE();

        if (parentStr == null){

     * @param myName

     * @param parser

     */

        String parentStr = myName.getGenusStr();

        Rank r = Rank.GENUS();

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSubgenusStr();

        Rank r = Rank.SUBGENUS();

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSpeciesStr();

        Rank r = Rank.SPECIES();

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSubspeciesStr();

        Rank r = Rank.SUBSPECIES();

     * @param myName

     * @param parser

     */

        String parentStr = myName.getSubspeciesStr();

        Rank r = Rank.SUBSPECIES();

     * @param r

     * @return

     */

        NonViralName<?> parentNameName =  (NonViralName<?>) parser.parseFullName(parentStr, nomenclaturalCode, r);

        Taxon parent = Taxon.NewInstance(parentNameName, ref); //sec set null

        //                    importer.getTaxonService().save(parent);