X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=org.argeo.slc%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fcore%2Fstructure%2Ftree%2FTreeSPath.java;h=b00d1cf9443bd6351258f36b6d88de01db3077ca;hb=c228c125b7f40d1716911dd66971c720dc9478b5;hp=94d22b592b6195ca6789e1569ea9a4d8fe8a3a06;hpb=2d2e8673ee9a9c610dcd831833cb67c3a508c372;p=gpl%2Fargeo-slc.git

diff --git a/org.argeo.slc/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java b/org.argeo.slc/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
index 94d22b592..b00d1cf94 100644
--- a/org.argeo.slc/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
+++ b/org.argeo.slc/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
@@ -1,57 +1,116 @@
 package org.argeo.slc.core.structure.tree;
 
+import java.util.List;
 import java.util.StringTokenizer;
+import java.util.Vector;
 
+import org.argeo.slc.core.SlcException;
 import org.argeo.slc.core.structure.StructurePath;
+import org.argeo.slc.core.structure.StructureRegistry;
 
-public class TreeSPath implements StructurePath {
+/**
+ * Path for tree based <code>StructureRegistry</code> implementations.
+ */
+public class TreeSPath implements StructurePath, Comparable<StructurePath> {
+	/** Default character to use a separator: #. */
 	public static Character DEFAULT_SEPARATOR = '#';
 
 	private TreeSPath parent;
 	private String name;
 	private Character separator = DEFAULT_SEPARATOR;
 
+	/** For ORM */
+	private Long tid;
+
 	public String getAsUniqueString() {
 		String parentStr = parent != null ? parent.getAsUniqueString() : "";
 		return parentStr + separator + name;
 	}
 
+	public void setAsUniqueString(String str) {
+		TreeSPath twin = parseToCreatePath(str, getSeparator());
+		name = twin.name;
+		parent = twin.parent;
+	}
+
+	/** The separator actually used by this path. */
 	public Character getSeparator() {
 		return separator;
 	}
 
+	/** Gets the parent path. */
 	public TreeSPath getParent() {
 		return parent;
 	}
 
+	/** Gets the name part of the path. */
 	public String getName() {
 		return name;
 	}
 
-	public static TreeSPath createChild(TreeSPath parent, String name) {
+	/** Create a path without parent. */
+	public static TreeSPath createRootPath(String name) {
+		TreeSPath path = new TreeSPath();
+		path.parent = null;
+		path.name = name;
+		return path;
+	}
+
+	/** Create a child . */
+	public TreeSPath createChild(String name) {
+		if (name.indexOf(separator) > -1) {
+			throw new SlcException("Tree path name '" + name
+					+ "' contains separator character " + separator);
+		}
 		TreeSPath path = new TreeSPath();
-		path.parent = parent;
+		path.parent = this;
 		path.name = name;
 		return path;
 	}
 
-	public static TreeSPath createTreeSPath(String path, Character separator) {
+	/** Parses a string to a path. */
+	public static TreeSPath parseToCreatePath(String path, Character separator) {
 		StringTokenizer st = new StringTokenizer(path, Character
 				.toString(separator));
 
 		TreeSPath currPath = null;
 		while (st.hasMoreTokens()) {
 			if (currPath == null) {// begin
-				currPath = createChild(null, st.nextToken());
+				currPath = createRootPath(st.nextToken());
 			} else {
-				currPath = createChild(currPath, st.nextToken());
+				currPath = currPath.createChild(st.nextToken());
 			}
 		}
 		return currPath;
 	}
+
+	public List<TreeSPath> listChildren(StructureRegistry registry) {
+		return listChildrenPaths(registry, this);
+	}
+
+	public static List<TreeSPath> listChildrenPaths(StructureRegistry registry,
+			TreeSPath path) {
+		List<TreeSPath> paths = new Vector<TreeSPath>();
+		List<StructurePath> allPaths = registry.listPaths();
+		for (StructurePath sPath : allPaths) {
+			TreeSPath pathT = (TreeSPath) sPath;
+			if (pathT.parent != null && pathT.parent.equals(path)) {
+				paths.add(pathT);
+			}
+		}
+		return paths;
+	}
+
+	public TreeSPath getRoot(){
+		TreeSPath root = this;
+		while(root.getParent()!=null){
+			root = root.getParent();
+		}
+		return root;
+	}
 	
 	@Override
-	public String toString(){
+	public String toString() {
 		return getAsUniqueString();
 	}
 
@@ -63,6 +122,29 @@ public class TreeSPath implements StructurePath {
 		}
 		return false;
 	}
-	
-	
+
+	public int compareTo(StructurePath o) {
+		return getAsUniqueString().compareTo(o.getAsUniqueString());
+	}
+
+	Long getTid() {
+		return tid;
+	}
+
+	void setTid(Long tid) {
+		this.tid = tid;
+	}
+
+	public void setSeparator(Character separator) {
+		this.separator = separator;
+	}
+
+	protected void setParent(TreeSPath parent) {
+		this.parent = parent;
+	}
+
+	protected void setName(String name) {
+		this.name = name;
+	}
+
 }