org.argeo.slc/src/main/java/org/argeo/slc/core/structure/tree/TreeSPath.java

   1 package org.argeo.slc.core.structure.tree;
   2
   3 import java.util.List;
   4 import java.util.StringTokenizer;
   5 import java.util.Vector;
   6
   7 import org.argeo.slc.core.structure.StructurePath;
   8 import org.argeo.slc.core.structure.StructureRegistry;
   9
  10 /**
  11  * Path for tree based <code>StructureRegistry</code> implementations.
  12  *
  13  * @see TreeSRegistry
  14  */
  15 public class TreeSPath implements StructurePath {
  16         /** Default character to use a separator: #. */
  17         public static Character DEFAULT_SEPARATOR = '#';
  18
  19         private TreeSPath parent;
  20         private String name;
  21         private Character separator = DEFAULT_SEPARATOR;
  22
  23         public String getAsUniqueString() {
  24                 String parentStr = parent != null ? parent.getAsUniqueString() : "";
  25                 return parentStr + separator + name;
  26         }
  27
  28         /** The separator actually used by this path. */
  29         public Character getSeparator() {
  30                 return separator;
  31         }
  32
  33         /** Gets the parent path. */
  34         public TreeSPath getParent() {
  35                 return parent;
  36         }
  37
  38         /** Gets the name part of the path. */
  39         public String getName() {
  40                 return name;
  41         }
  42
  43         /** Create a path without parent. */
  44         public static TreeSPath createRootPath(String name) {
  45                 TreeSPath path = new TreeSPath();
  46                 path.parent = null;
  47                 path.name = name;
  48                 return path;
  49         }
  50
  51         /** Create a child . */
  52         public TreeSPath createChild(String name) {
  53                 TreeSPath path = new TreeSPath();
  54                 path.parent = this;
  55                 path.name = name;
  56                 return path;
  57         }
  58
  59         /** Parses a string to a path. */
  60         public static TreeSPath parseToCreatePath(String path, Character separator) {
  61                 StringTokenizer st = new StringTokenizer(path, Character
  62                                 .toString(separator));
  63
  64                 TreeSPath currPath = null;
  65                 while (st.hasMoreTokens()) {
  66                         if (currPath == null) {// begin
  67                                 currPath = createRootPath(st.nextToken());
  68                         } else {
  69                                 currPath = currPath.createChild(st.nextToken());
  70                         }
  71                 }
  72                 return currPath;
  73         }
  74
  75         public List<TreeSPath> listChildren(StructureRegistry registry){
  76                 return listChildrenPaths(registry, this);
  77         }
  78
  79         public static List<TreeSPath> listChildrenPaths(StructureRegistry registry,
  80                         TreeSPath path) {
  81                 List<TreeSPath> paths = new Vector<TreeSPath>();
  82                 List<StructurePath> allPaths = registry.listPaths();
  83                 for (StructurePath sPath : allPaths) {
  84                         TreeSPath pathT = (TreeSPath) sPath;
  85                         if (pathT.parent != null && pathT.parent.equals(path)) {
  86                                 paths.add(pathT);
  87                         }
  88                 }
  89                 return paths;
  90         }
  91
  92         @Override
  93         public String toString() {
  94                 return getAsUniqueString();
  95         }
  96
  97         @Override
  98         public boolean equals(Object obj) {
  99                 if (obj instanceof StructurePath) {
 100                         StructurePath path = (StructurePath) obj;
 101                         return getAsUniqueString().equals(path.getAsUniqueString());
 102                 }
 103                 return false;
 104         }
 105
 106 }