EDIT

//        return new JAXBElement( new QName(Namespaces.NS_WORD12, "fldChar"), org.docx4j.wml.FldChar.class, fldchar);

//    }

        String styleId = "Heading"+indent;

        for (FeatureNode childNode : node.getChildNodes()) {

    private Map<String,String> citations = new HashMap<>();

    private Map<String,String> defaultUnitPrefixes = new HashMap<>();

    private Map<String,Person> editors = new HashMap<>();

    private Map<String,Feature> features = new HashMap<>();

    private Map<String,String> locations = new HashMap<>();

    private Map<String,List<CdmBase>> mediaObject_ListCdmBase = new HashMap<>();

					FeatureTree featureTree =  FeatureTree.NewInstance();

					importRepresentation(elCharacterTree, sddNamespace, featureTree, "", cdmState);

					List<Element> listeOfNodes = elCharacterTree.getChildren("Nodes", sddNamespace);

					//Nodes of CharacterTrees in SDD always refer to DescriptiveConcepts

	 * @param root

	 * @param elNodes

	 */

		List<Element> listNodes = elNodes.getChildren("Node", sddNamespace);

		if (listNodes != null) {

			for (Element elNode : listNodes){

				String idN = elNode.getAttributeValue("id");

				Feature dc = null;

				if (idN!=null) {

					// DescriptiveConcepts are used as nodes in CharacterTrees

					if (elParent!=null){

						String refP = elParent.getAttributeValue("ref");

						if (refP!=null) {

							if (parent==null){

								root.addChild(fn); // if no parent found or the reference is broken, add the node to the root of the tree

							}

				Element elParent = elCharNode.getChild("Parent", sddNamespace);

				Element elCharacter = elCharNode.getChild("Character", sddNamespace);

				Element elDependencyRules = elCharNode.getChild("DependencyRules", sddNamespace);

				if (elDependencyRules!=null){

					Element elInapplicableIf = elCharNode.getChild("InapplicableIf", sddNamespace);

				if (elParent!=null){

					String refP = elParent.getAttributeValue("ref");

					if ((refP!=null)&&(!refP.equals(""))) {

						if (parent==null){

						parent = root; // if no parent found or the reference is broken, add the node to the root of the tree

						}

				String refC = elCharacter.getAttributeValue("ref");

				if ((refC!=null)&&(!refC.equals(""))){

					Feature character = features.get(refC);

					featureNodes.put(refC, fn);

				}

			}

		}

	}

			boolean isRoot) {

		if (!parent.isLeaf()) {

			ElementImpl elCharNode = new ElementImpl(document, NODE);

			charnodeCount = buildReference(parent, featuretrees, ID,

			}

			ElementImpl elDescriptiveConcept = new ElementImpl(document,

					DESCRIPTIVE_CONCEPT);

			descriptiveConceptCount = buildReference(fref, descriptiveConcepts,

					REF, elDescriptiveConcept, "dc", descriptiveConceptCount);

			elCharNode.appendChild(elDescriptiveConcept);

			element.appendChild(elCharNode);

				FeatureNode fn = ifn.next();

				buildBranches(fn, element, false);

			}

			charnodeCount = buildReference(parent, featuretrees, ID,

					elCharNode, "cn", charnodeCount);

			ElementImpl elCharacter = new ElementImpl(document, CHARACTER);

			boolean dependencies = false;

			ElementImpl elDependecyRules = new ElementImpl(document,

					"DependecyRules");

        if (proibiospheretree == null){

            List<FeatureTree> trees = importer.getFeatureTreeService().list(FeatureTree.class, null, null, null, null);

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

                if (featuresMap==null) {

                    featuresMap=new HashMap<String, Feature>();

                }

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

                                }

                                else {

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

                                }

/**

* Copyright (C) 2009 EDIT

* 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.model.description.FeatureTree;

public class FeatureTest {

	    private String resource = "/eu/etaxonomy/cdm/io/jaxb/FeatureTest.xml";

	    @Test

	    public void testUnmarshalFeatureTree() throws Exception {

	        CdmDocumentBuilder cdmDocumentBuilder = new CdmDocumentBuilder();

	        URI uri = new URI(URIEncoder.encode(this.getClass().getResource(resource).toString()));

	        DataSet dataSet = cdmDocumentBuilder.unmarshal(DataSet.class, new InputStreamReader(this.getClass().getResourceAsStream(resource)),uri.toString());

			Feature feature = (Feature)dataSet.getTerms().get(1);

			assertNotNull("FeatureTree must not be null",featureTree);

			assertNotNull("Feature must not be null",feature);

			assertNotNull("FeatureTree.root must not be null",featureTree.getRoot());

			FeatureNode featureNode = featureTree.getRoot();

			assertNotNull("FeatureNode.children must not be null",featureNode.getChildNodes());

			assertFalse("FeatureNode.children must not be empty",featureNode.getChildNodes().isEmpty());

			assertEquals("FeatureNode.children must have 4 child nodes",4,featureNode.getChildNodes().size());

	    }

}

	@XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	@XmlElementWrapper(name = "Descriptions")

	@XmlElement(name = "Description")

		}

	}

		return descriptiveSystem;

	}

		this.descriptiveSystem = descriptiveSystem;

	}

import org.hibernate.envers.Audited;

import eu.etaxonomy.cdm.hibernate.HHH_9751_Util;

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

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

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

@Entity

@Audited

@Table(name="FeatureNode", indexes = { @Index(name = "featureNodeTreeIndex", columnList = "treeIndex") })

	private static final Logger logger = Logger.getLogger(FeatureNode.class);

    //This is the main key a node belongs to. Although other keys may also reference

	@XmlElement(name = "FeatureTree")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE}) //TODO this usage is incorrect, needed only for OneToMany, check why it is here, can it be removed??

	 //TODO Val #3379

//    @NotNull

    /**

     * The {@link TermType type} of this term node.

    @XmlElement(name = "Feature")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @XmlElement(name = "Parent")

    @XmlIDREF

    @ManyToOne(fetch = FetchType.LAZY, targetEntity=FeatureNode.class)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	@JoinColumn(name="parent_id")

    @XmlElement(name = "treeIndex")

    //see https://dev.e-taxonomy.eu/trac/ticket/3722

    @OrderColumn(name="sortIndex")

    @OrderBy("sortIndex")

	@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})

    //see https://dev.e-taxonomy.eu/trac/ticket/3722

    private Integer sortIndex;

     *

     * @see #NewInstance(Feature)

     */

    }

	/**

	 *

	 * @see #NewInstance(Feature)

	 */

	}

	/**

	 * @param	term	the term assigned to the new feature node

	 * @see 			#NewInstance()

	 */

	    result.setTerm(term);

	    return result;

	}

//*************************** TREE ************************************/

		return featureTree;

	}

		checkTermType(featureTree);

	    this.featureTree = featureTree;

	}

//** ********************** FEATURE ******************************/

	/**

     * Returns the {@link Feature feature} <i>this</i> feature node is based on.

     */

        return feature;

    }

    /**

     * @see #getFeature()

     */

        checkTermType(term);

        this.feature = term;

    }

	 * @see	#getChildNodes()

	 */

	@Override

		return parent;

	}

	/**

	 * @param	parent	the feature node to be set as parent

	 * @see				#getParent()

	 */

		checkTermType(parent);

	    this.parent = parent;

	}

	 * <i>this</i> feature node.

	 */

	@Override

	    return children;

	}

	 * @see				#removeChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

		addChild(child, children.size());

	}

	/**

	 * @see				#removeChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

	    checkTermType(child);

		if (index < 0 || index > children.size() + 1){

			throw new IndexOutOfBoundsException("Wrong index: " + index);

		}

	 * @see				#addChild(FeatureNode)

	 * @see				#removeChild(int)

	 */

	    int index = children.indexOf(child);

		if (index >= 0){

	 * @see				#removeChild(FeatureNode)

	 */

	public void removeChild(int index){

	   if (child != null){

			children.remove(index);

			child.setParent(null);

			child.setFeatureTree(null);

			//TODO workaround (see sortIndex doc)

			for(int i = 0; i < children.size(); i++){

				childAt.setSortIndex(i);

			}

			child.setSortIndex(null);

	 * @see					#addChild(FeatureNode, int)

	 * @see					#removeChild(int)

	 */

	    return children.get(childIndex);

	}

	 * @see			#addChild(FeatureNode, int)

	 * @see			#removeChild(int)

	 */

	    if (! children.contains(node)){

			return -1;

		}else{

    }

	/**

	 *

	 * @param featureNode

	 * @param features

	 * @return

	 */

	@Transient

		}

			features.addAll(childNode.getDistinctFeaturesRecursive(features));

		}

		return features;

	}

				childClone.addChild(childChild.cloneDescendants());

			}

			clone.addChild(childClone);

	 */

	@Override

	public Object clone() {

		try {

			result.children = new ArrayList<>();

			return result;

		}catch (CloneNotSupportedException e) {

import org.hibernate.annotations.Type;

import org.hibernate.envers.Audited;

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

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

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

//@Indexed disabled to reduce clutter in indexes, since this type is not used by any search

//@Indexed(index = "eu.etaxonomy.cdm.model.description.FeatureTree")

@Audited

            extends IdentifiableEntity<IIdentifiableEntityCacheStrategy>

            implements IHasTermType, Cloneable{

	private static final Logger logger = Logger.getLogger(FeatureTree.class);

	@XmlElement(name = "Root")

	@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE})

    /**

     * The {@link TermType type} of this term collection. All nodes in the graph must refer to a term of the same type.

     * with an empty {@link #getRoot() root node}.

     * @param termType the {@link TermType term type}, must not be null

     */

    }

    /**

	 * @see #NewInstance(UUID)

	 * @see #NewInstance(List)

	 */

	}

	/**

	 * @see 			#NewInstance()

	 * @see 			#NewInstance(List)

	 */

		result.setUuid(uuid);

		return result;

	}

	 * @see 				#NewInstance()

	 * @see 				#NewInstance(UUID)

	 */

		for (Feature feature : featureList){

			root.addChild(child);

		}

	 * recursively point to their child nodes the complete feature tree is

	 * defined by its root node.

	 */

		return root;

	}

	 * children of the root node of <i>this</i> feature tree.

	 */

	@Transient

		result.addAll(root.getChildNodes());

		return result;

	}

//******************** METHODS ***********************************************/

	/**

	 *

	 * @return

	 */

	@Transient

	    if(termType.equals(TermType.Feature) || termType.isKindOf(TermType.Feature)){

	        return root.getDistinctFeaturesRecursive(features);

	    }

	    String message = "FeatureTree is not of type FEATURE.";

	 */

	@Override

	public Object clone() {

		try {

		}catch (CloneNotSupportedException e) {

			logger.warn("Object does not implement cloneable");

			e.printStackTrace();

			return null;

		}

		result.root = rootClone;

		return result;

	 *

	 * @param node

	 */

		if (node.getOnlyApplicableIf()!=null){

			Set<State> addToOAI = node.getOnlyApplicableIf();

			for (State state : addToOAI){

				if (oAIdependencies.containsKey(state)) {

                    oAIdependencies.put(state, new HashSet<Feature>());

                }

			}

		}

		if (node.getInapplicableIf()!=null){

				if (iIdependencies.containsKey(state)) {

                    iIdependencies.put(state, new HashSet<Feature>());

                }

			}

		}

		if (node.getChildNodes()!=null) {

            }   else if(FeatureTree.class.isAssignableFrom(entityClazz)){

                    node.removeNullValueFromChildren();

                    if (node.getChildNodes() != null){

                        for (FeatureNode childNode: node.getChildNodes()){

        DescriptiveDataSet dataSet = load(descriptiveDataSetUuid);

        SpecimenOrObservationBase specimen = occurrenceService.load(specimenUuid);

        List<DescriptionElementBase> matchingDescriptionElements = new ArrayList<>();

        for (SpecimenDescription specimenDescription : (Set<SpecimenDescription>) specimen.getDescriptions()) {

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

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

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

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

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

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

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

/**

 * Generator of natural language descriptions from TaxonDescriptions.

 * @author m.venin

 * @since 13.04.2010

 * @version 1.0

	private DescriptionBuilder<CategoricalData> categoricalDescriptionBuilder = new DefaultCategoricalDescriptionBuilder();

	private TextData previousTextData;

	DeltaTextDataProcessor deltaTextDataProcessor = new DeltaTextDataProcessor();

	private Map<String, INaturalLanguageTextDataProcessor> elementProcessors;

	/**

	 * Change the first separator used by generateSingleTextData. By default ",".

	 * @param separator

	 */

	public void setFirstSeparator(String separator){

	/**

	 * Change the second separator used by generateSingleTextData. By default ".".

	 * @param separator

	 */

	public void setSecondSeparator(String separator){

	 * The keys of the elementProcessors map are regular expressions which are

	 * being used to identify the those Descriptions to which the mapped

	 * NaturalLanguageTextDataProcessor is applicable.

	 * @param elementProcessors

	 */

	public void setElementProcessors(

	 * Looks for technical annotations, if one matches a regular expression of the element processors

	 * the associated processor is added to the applicable element processors which will then be applied

	 * when generating the description.

	 * @param annotations the set of annotations of the description

	 */

	private void initNaturalLanguageDescriptionElementProcessors(Set<Annotation> annotations) {

	/**

	 * Applies the list of applicable processors to a TextData.

	 * @param textData the TextData to be modified

	 * @param previousTextData the TextData corresponding to the feature of the previous level in the tree

	 */

	/**

	 * The most simple function to generate a description. The language used is the default one.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @return a list of TextData, each one being a basic element of the natural language description

	 */

		return generateNaturalLanguageDescription(featureTree,description,Language.DEFAULT());

	}

	/**

	 * Generate a description in a specified language.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @param language the language in which the description has to be printed

	 * @return a list of TextData, each one being a basic element of the natural language description

	 */

		List<Language> languages = new ArrayList<Language>();

		languages.add(language);

		initNaturalLanguageDescriptionElementProcessors(description.getAnnotations());

	/**

	 * Generate a description with a specified list of preferred languages.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @param languages the ordered list of languages preferred for printing the description

	 * @return a list of TextData, each one being a basic element of the natural language description

	 */

		initNaturalLanguageDescriptionElementProcessors(description.getAnnotations());

		return buildBranchesDescr(featureTree.getRootChildren(), featureTree.getRoot(), description, languages,0);

	}

	/**

	 * Generate a description as a single paragraph in a TextData.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @return a TextData in the default language.

	 */

		return generateSingleTextData(featureTree,description,Language.DEFAULT());

	}

	/**

	 * Generate a description as a single paragraph in a TextData.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @param language the language in which the description has to be printed

	 * @return a TextData in the specified language.

	 */

		List<Language> languages = new ArrayList<Language>();

		languages.add(language);

		return generatePreferredSingleTextData(featureTree,description,languages);

	/**

	 * Generate a description with a specified list of preferred languages.

	 * @param featureTree the FeatureTree holding the order in which features and their states must be printed

	 * @param description the TaxonDescription with all the data

	 * @param languages the ordered list of languages preferred for printing the description

	 * @return a TextData using the languages (in the given order of preference)

	 */

		levels.clear(); // before the start, the table containing the levels of each node must be cleared

		// Note: this is not the most efficient way to keep track of the levels of the nodes but it allows some flexibility

		List<TextData> texts = generatePreferredNaturalLanguageDescription(featureTree,description, languages);// first get the description as a raw list of TextData

					startSentence=true;

					firstOne=false;

					String asString = texts.get(i).getText(Language.DEFAULT()).toString();

				}

				i++;

			}

			else if (level==0) { // if this node is a leaf

				startSentence=false;

				i++;

			}

			else {

				if (!firstOne && levels.get(j-1).equals(0)){ // if this node corresponds to the states linked to the previous leaf

					i++;

				}

			}

	/** recursive function that goes through a tree containing the order in which the description has to be generated,

	 *  if an element of this tree matches one of the TaxonDescription, a DescriptionBuilder is called which returns a TextData with the corresponding description.

	 * @param children the children of the feature node considered

	 * @param parent the feature node considered

	 * @param description the TaxonDescription element for which we want a natural language output

	 * @param floor integer to keep track of the level in the tree

	 * @return a list of TextData elements containing the part of description corresponding to the feature node considered

	 */

		List<TextData> listTextData = new ArrayList<TextData>();

		floor++; // counter to know the current level in the tree

		if (!parent.isLeaf()){ // if this node is not a leaf, continue recursively (only the leaves of a FeatureTree contain states)

			levels.add(new Integer(floor)); // the level of the different nodes in the tree are kept, thus it is easier to build a structured text out of the List<TextData>

			TextData featureName;

			if (feature!=null && feature.getLabel()!=null){ // if a node is associated to a feature

				featureName = categoricalDescriptionBuilder.buildTextDataFeature(feature, languages);

				levels.add(new Integer(-1)); // it is indicated by a '-1' after its level

				listTextData.add(featureName); // the TextData representing the name of the feature is concatenated to the list

			}

			for (Iterator<FeatureNode> ifn = children.iterator() ; ifn.hasNext() ;){

				previousTextData = featureName; // this allows to keep track of the name of the feature one level up in the tree

			}

		}

		else { //once a leaf is reached

			if (feature!=null && (feature.isSupportsQuantitativeData() || feature.isSupportsCategoricalData())) {

				Set<DescriptionElementBase> elements = description.getElements();

				for (Iterator<DescriptionElementBase> deb = elements.iterator() ; deb.hasNext() ;){ // iterates over all the descriptions enclosed in the TaxonDescription

			}

		}

		return listTextData;

}