| package org.eclipse.sensinact.studio.model.resource.utils; |
| |
| /** |
| * |
| */ |
| public abstract class AbstractDescriptor implements Descriptor{ |
| |
| public static String pathFormat(String path) { |
| if(path == null || path.trim().equals("/")) |
| return "/"; |
| |
| String formatedPath = path.trim(); |
| if(!path.startsWith("/")) |
| formatedPath="/"+formatedPath; |
| |
| if(path.endsWith("/")) |
| formatedPath=formatedPath.substring(0,formatedPath.length()-1); |
| |
| return formatedPath; |
| } |
| |
| protected String gateway; |
| |
| protected AbstractDescriptor(String gateway) { |
| this.gateway = gateway; |
| } |
| |
| public String getParentPath() { |
| String path = getPath(); |
| int index = path.lastIndexOf('/'); |
| return path.substring(0, index); |
| } |
| |
| @Override |
| public String toString() { |
| return this.gateway + getPath(); |
| } |
| |
| @Override |
| public String commonBranch(Descriptor descriptor) { |
| if(descriptor == null || !this.gateway.equals(descriptor.getGateway())) |
| return null; |
| |
| String path = pathFormat(descriptor.getPath()); |
| String localPath = pathFormat(getPath()); |
| |
| int localLength = localPath.length(); |
| int pathLength = path.length(); |
| |
| int lastSep = -1; |
| int index = 0; |
| |
| while(index < pathLength && index < localLength) { |
| if(localPath.charAt(index)!=path.charAt(index)) { |
| index = lastSep; |
| break; |
| } |
| if(localPath.charAt(index)=='/') |
| lastSep = index; |
| |
| index++; |
| } |
| if(index==0) |
| return null; |
| |
| return localPath.substring(0,index); |
| } |
| |
| @Override |
| public String getGateway(){ |
| return this.gateway; |
| } |
| |
| /** |
| * @inheritDoc |
| * |
| * @see java.lang.Comparable#compareTo(java.lang.Object) |
| * |
| * TODO Documentation: |
| * Compares this object with the specified object for order. Returns a |
| * negative integer, zero, or a positive integer as this object is less |
| * than, equal to, or greater than the specified object. The implementor |
| * must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. |
| * (This implies that x.compareTo(y) must throw an exception |
| * iff y.compareTo(x) throws an exception.) |
| * The implementor must also ensure that the relation is transitive: |
| * (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0. |
| * Finally, the implementor must ensure that x.compareTo(y)==0 implies that |
| * sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z. It is strongly |
| * recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). |
| * Generally speaking, any class that implements the Comparable interface and |
| * violates this condition should clearly indicate this fact. The recommended |
| * language is "Note: this class has a natural ordering that is inconsistent |
| * with equals." In the foregoing description, the notation sgn(expression) |
| * designates the mathematical signum function, which is defined to return |
| * one of -1, 0, or 1 according to whether the value of expression is negative, |
| * zero or positive. |
| */ |
| @Override |
| public int compareTo(Descriptor descriptor) { |
| if(this.gateway.equals(descriptor.getGateway())){ |
| |
| String path = pathFormat(descriptor.getPath()); |
| String localPath = pathFormat(getPath()); |
| |
| if(path.startsWith(localPath)) |
| return -1; |
| |
| if(localPath.startsWith(path)) |
| return 1; |
| } |
| return 0; |
| } |
| } |