}
}
+
/**
* Orders a Collection of {@link IEnumTerm}s according to the term
* hierarchy. The hierarchy will be reduced to two layers: one layer being
}
}
+
+// /**
+// * Orders a Collection of {@link IEnumTerm}s according to the term
+// * hierarchy. The hierarchy will be reduced to two layers: one layer being
+// * the root elements (that have no parents) and the other being their
+// * children and children's children recursively.<br>
+// * The returned map will be be ordered primarily by root elements and
+// * secondarily by the child elements, both ascending alphabetically. <br>
+// * <br>
+// * The reduced hierarchy could look like this:<br>
+// * <ul>
+// * <li>Root1
+// * <ul>
+// * <li>child1
+// * <li>child2
+// * <li>childOfChild2
+// * </ul>
+// * <li>root2
+// * <ul><li>child4</ul>
+// * </ul>
+// *
+// * @param terms
+// * A {@link Collection} of {@link IEnumTerm}s for which the term
+// * hierarchy should be created
+// * @return a map which holds the terms as keys and their string
+// * representation via {@link IEnumTerm#getMessage()} as values
+// */
+// public static <T extends IEnumTerm<?>> LinkedHashMap<T, String> orderTerms(Collection<T> terms) {
+// Comparator<TermNode<T>> comparator = new Comparator<TermNode<T>>() {
+// @Override
+// public int compare(TermNode<T> t1, TermNode<T> t2) {
+// return t1.getTerm().getMessage().compareTo(t2.getTerm().getMessage());
+// }
+// };
+// TreeSet<TermNode<T>> parentElements = new TreeSet<TermNode<T>>(comparator);
+// for(T term : terms) {
+// Set<T> childList = new TreeSet<T>(comparator);
+// // add root element as keys
+// if(term.getKindOf()==null){
+// parentElements.add(new TermNode<T>(term));
+// }
+// // add child element to parent
+// else{
+// T parent = getParentFor(term);
+// if(termHierarchy.containsKey(parent)){
+// termHierarchy.get(parent).add(term);
+// }
+// else{
+// childList.add(term);
+// termHierarchy.put(parent, childList);
+// }
+// }
+// }
+//
+// // create list according to the type hierarchy (root elements alphabetically with recursive children also alphabetically)
+// LinkedHashMap<T, String> result = new LinkedHashMap<T, String>();
+// for(Entry<T, Set<T>> entry:termHierarchy.entrySet()){
+// T root = entry.getKey();
+// result.put(root, root.getMessage());
+// for(T child:entry.getValue()){
+// result.put(child, " " + child.getMessage());
+// }
+// }
+// return result;
+// }
+//
+// private static addToParents(TreeSet<TermNode<T>> parents, Collection<T> terms){
+// for(T term:terms){
+//
+// }
+// }
+//
+// @SuppressWarnings("unchecked")
+// /**
+// * Recursively iterates over all term parents until no more parent is found i.e. the root node
+// * @param term The term for which the parent should be found
+// * @return the root terms of the term hierarchy
+// */
+// private static<T extends IEnumTerm<?>> T getParentFor(T term){
+// // PP: cast should be safe. Why is Eclipse complaining??
+// T parent = (T) term.getKindOf();
+// if(parent==null){
+// return term;
+// }
+// else{
+// return getParentFor((T) term.getKindOf());
+// }
+// }
+//
+// private class TermNode<T>{
+// private final T term;
+// private final TreeSet<TermNode<T>> children;
+//
+// /**
+// * @param term
+// * @param children
+// */
+// public TermNode(T term) {
+// super();
+// this.term = term;
+// this.children = new TreeSet<TermNode<T>>();
+// }
+//
+// public void addChild(TermNode<T> child){
+// this.children.add(child);
+// }
+//
+// /**
+// * @return the children
+// */
+// public TreeSet<TermNode<T>> getChildren() {
+// return children;
+// }
+//
+// /**
+// * @return the term
+// */
+// public T getTerm() {
+// return term;
+// }
+// }
+
}