X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=org.argeo.slc.core%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fcore%2Fstructure%2Ftree%2FTreeSPath.java;h=f02fbda5d8969ffcd757da72fd4c8bebbcdbac3d;hb=62e442adb36b006627b17061864dfa4edde0a99a;hp=c8564cb9a491f738c3c57ac954ed580d837aac14;hpb=f92c2606ca48ffd9baaa140478ef11fe7d3bfd66;p=gpl%2Fargeo-slc.git

diff --git a/org.argeo.slc.core/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java b/org.argeo.slc.core/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
index c8564cb9a..f02fbda5d 100644
--- a/org.argeo.slc.core/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
+++ b/org.argeo.slc.core/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java
@@ -13,25 +13,35 @@ import org.argeo.slc.core.structure.StructureRegistry;
  */
 public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 	/** Default character to use a separator: /. */
-	public static Character DEFAULT_SEPARATOR = '/';
+	private static Character DEFAULT_SEPARATOR = '/';
 
-	private TreeSPath parent;
-	private String name;
 	private Character separator = DEFAULT_SEPARATOR;
 
+	private String asUniqueString;
+
 	/** For ORM */
 	private Long tid;
 
+	public TreeSPath() {
+
+	}
+
+	public TreeSPath(String asUniqueString) {
+		this.asUniqueString = checkAndFormatPath(asUniqueString);
+	}
+
 	public String getAsUniqueString() {
-		String parentStr = parent != null ? parent.getAsUniqueString() : "";
-		return parentStr + separator + name;
+		return asUniqueString;
 	}
 
-	/** Sets all the required data from a string. */
+	/**
+	 * Sets all the required data from a string. <b>ATTENTION</b>: the path is
+	 * not checked for performance reason. This method should be used only by
+	 * ORM/OXM frameworks. Use constructor to create immutable tree structure
+	 * paths.
+	 */
 	public void setAsUniqueString(String str) {
-		TreeSPath twin = parseToCreatePath(str, getSeparator());
-		name = twin.name;
-		parent = twin.parent;
+		this.asUniqueString = str;
 	}
 
 	/** The separator actually used by this path. */
@@ -41,20 +51,26 @@ public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 
 	/** Gets the parent path. */
 	public TreeSPath getParent() {
-		return parent;
+		int lastSep = getAsUniqueString().lastIndexOf(separator);
+		if (lastSep < 1) {
+			return null;
+		}
+		String parentUniqueString = getAsUniqueString().substring(0, lastSep);
+		return new TreeSPath(parentUniqueString);
 	}
 
 	/** Gets the name part of the path. */
 	public String getName() {
-		return name;
+		int lastSep = getAsUniqueString().lastIndexOf(separator);
+		return getAsUniqueString().substring(lastSep);
 	}
 
 	/** Create a path without parent. */
 	public static TreeSPath createRootPath(String name) {
-		TreeSPath path = new TreeSPath();
-		path.parent = null;
-		path.name = name;
-		return path;
+		if (name.indexOf(DEFAULT_SEPARATOR) >= 0) {
+			throw new SlcException("Name cannot contain " + DEFAULT_SEPARATOR);
+		}
+		return new TreeSPath('/' + name);
 	}
 
 	/** Create a child . */
@@ -63,46 +79,56 @@ public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 			throw new SlcException("Tree path name '" + name
 					+ "' contains separator character " + separator);
 		}
-		TreeSPath path = new TreeSPath();
-		path.parent = this;
-		path.name = name;
-		return path;
+		return new TreeSPath(getAsUniqueString() + '/' + name);
 	}
 
-	/** Parses a string to a path. */
+	/**
+	 * Parses a string to a path.
+	 * 
+	 * @deprecated use constructor instead
+	 */
 	public static TreeSPath parseToCreatePath(String path) {
 		return parseToCreatePath(path, DEFAULT_SEPARATOR);
 	}
 
-	/** Parses a string to a path. */
-	public static TreeSPath parseToCreatePath(String path, Character separator) {
-		StringTokenizer st = new StringTokenizer(path, Character
-				.toString(separator));
+	protected String checkAndFormatPath(String str) {
+		if (str.length() < 2) {
+			throw new SlcException("Path " + str + " is not short");
+		}
+		if (str.charAt(0) != separator) {
+			throw new SlcException("Path " + str + " have to start with "
+					+ separator);
+		}
 
-		TreeSPath currPath = null;
+		StringBuffer buf = new StringBuffer(str.length() + 5);
+		StringTokenizer st = new StringTokenizer(str, separator.toString());
 		while (st.hasMoreTokens()) {
-			if (currPath == null) {// begin
-				currPath = createRootPath(st.nextToken());
-			} else {
-				currPath = currPath.createChild(st.nextToken());
-			}
+			buf.append(separator).append(st.nextToken());
 		}
-		return currPath;
+		return buf.toString();
+	}
+
+	/**
+	 * Parses a string to a path.
+	 * 
+	 * @deprecated use constructor instead
+	 */
+	public static TreeSPath parseToCreatePath(String path, Character separator) {
+		return new TreeSPath(path);
 	}
 
 	/** Lists the children from a registry. */
-	public List<TreeSPath> listChildren(StructureRegistry registry) {
+	public List<TreeSPath> listChildren(StructureRegistry<TreeSPath> registry) {
 		return listChildrenPaths(registry, this);
 	}
 
 	/** Lists the children from a given path from a registry. */
-	public static List<TreeSPath> listChildrenPaths(StructureRegistry registry,
-			TreeSPath path) {
+	public static List<TreeSPath> listChildrenPaths(
+			StructureRegistry<TreeSPath> 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)) {
+		List<TreeSPath> allPaths = registry.listPaths();
+		for (TreeSPath pathT : allPaths) {
+			if (pathT.getParent() != null && pathT.getParent().equals(path)) {
 				paths.add(pathT);
 			}
 		}
@@ -123,7 +149,7 @@ public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 		return depthImpl(this);
 	}
 
-	private static int depthImpl(TreeSPath path) {
+	protected int depthImpl(TreeSPath path) {
 		if (path.getParent() == null) {
 			return 1;
 		} else {
@@ -131,6 +157,21 @@ public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 		}
 	}
 
+	public List<TreeSPath> getHierarchyAsList() {
+		List<TreeSPath> lst = new Vector<TreeSPath>();
+		addParentToList(lst, this);
+		lst.add(this);
+		return lst;
+	}
+
+	protected void addParentToList(List<TreeSPath> lst, TreeSPath current) {
+		TreeSPath parent = current.getParent();
+		if (parent != null) {
+			addParentToList(lst, parent);
+			lst.add(parent);
+		}
+	}
+
 	@Override
 	public String toString() {
 		return getAsUniqueString();
@@ -145,31 +186,20 @@ public class TreeSPath implements StructurePath, Comparable<StructurePath> {
 		return false;
 	}
 
+	@Override
+	public int hashCode() {
+		return getAsUniqueString().hashCode();
+	}
+
 	public int compareTo(StructurePath o) {
 		return getAsUniqueString().compareTo(o.getAsUniqueString());
 	}
 
-	Long getTid() {
+	public Long getTid() {
 		return tid;
 	}
 
 	void setTid(Long tid) {
 		this.tid = tid;
 	}
-
-	/** Sets the separator character to use. */
-	public void setSeparator(Character separator) {
-		this.separator = separator;
-	}
-
-	/** Sets the parent (for ORM). */
-	protected void setParent(TreeSPath parent) {
-		this.parent = parent;
-	}
-
-	/** Sets the name (for ORM). */
-	protected void setName(String name) {
-		this.name = name;
-	}
-
 }