X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.browsing.ui%2Fsrc%2Forg%2Fsimantics%2Fbrowsing%2Fui%2FNodeContextPath.java;h=1a5c5806198fef7f26d0a3ae240785738697cc3a;hp=9c09bc4dde914ba88b200010fb936045202be091;hb=0ae2b770234dfc3cbb18bd38f324125cf0faca07;hpb=24e2b34260f219f0d1644ca7a138894980e25b14

diff --git a/bundles/org.simantics.browsing.ui/src/org/simantics/browsing/ui/NodeContextPath.java b/bundles/org.simantics.browsing.ui/src/org/simantics/browsing/ui/NodeContextPath.java
index 9c09bc4dd..1a5c58061 100644
--- a/bundles/org.simantics.browsing.ui/src/org/simantics/browsing/ui/NodeContextPath.java
+++ b/bundles/org.simantics.browsing.ui/src/org/simantics/browsing/ui/NodeContextPath.java
@@ -1,257 +1,257 @@
-/*******************************************************************************
- * Copyright (c) 2005, 2007 IBM Corporation and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     IBM Corporation - initial API and implementation
- *******************************************************************************/
-package org.simantics.browsing.ui;
-
-import java.util.Arrays;
-
-import org.eclipse.core.runtime.Assert;
-import org.eclipse.core.runtime.IAdaptable;
-
-/**
- * A {@link GraphExplorer} tree {@link NodeContext} path denotes a model element
- * in a tree viewer. Tree path objects have value semantics. A model element is
- * represented by a path of elements in the tree from the root element to the
- * leaf element.
- * <p>
- * Clients may instantiate this class. Not intended to be subclassed.
- * </p>
- * 
- * <p>
- * Directly imitated for the Simantics browsing framework from JFace
- * <code>org.eclipse.jface.viewer.TreePath</code> class.
- * </p>
- * 
- * @author Tuukka Lehtonen
- */
-public final class NodeContextPath implements IAdaptable {
-
-    public static final NodeContextPath[] NONE  = {};
-
-    /**
-     * Constant for representing an empty tree path.
-     */
-    public static final NodeContextPath   EMPTY = new NodeContextPath(NodeContext.NONE);
-
-    private final NodeContext[]           segments;
-
-    private int                           hash;
-
-    /**
-     * Constructs a path identifying a leaf node in a tree.
-     * 
-     * @param segments
-     *            path of elements to a leaf node in a tree, starting with the
-     *            root element
-     */
-    public NodeContextPath(NodeContext... segments) {
-        Assert.isNotNull(segments);
-        for (int i = 0; i < segments.length; i++) {
-            Assert.isNotNull(segments[i]);
-        }
-        this.segments = segments;
-    }
-
-    /**
-     * Returns the element at the specified index in this path.
-     * 
-     * @param index
-     *            index of element to return
-     * @return element at the specified index
-     */
-    public NodeContext getSegment(int index) {
-        return segments[index];
-    }
-
-    /**
-     * Returns the number of elements in this path.
-     * 
-     * @return the number of elements in this path
-     */
-    public int getSegmentCount() {
-        return segments.length;
-    }
-
-    /**
-     * Returns the first element in this path, or <code>null</code> if this
-     * path has no segments.
-     * 
-     * @return the first element in this path
-     */
-    public NodeContext getFirstSegment() {
-        if (segments.length == 0) {
-            return null;
-        }
-        return segments[0];
-    }
-
-    /**
-     * Returns the last element in this path, or <code>null</code> if this
-     * path has no segments.
-     * 
-     * @return the last element in this path
-     */
-    public NodeContext getLastSegment() {
-        if (segments.length == 0) {
-            return null;
-        }
-        return segments[segments.length - 1];
-    }
-
-    /**
-     * @return all the segments in the path as an array
-     */
-    public NodeContext[] getSegments() {
-        if (segments.length == 0)
-            return segments;
-        return Arrays.copyOf(segments, segments.length);
-    }
-
-    /*
-     * (non-Javadoc)
-     * 
-     * @see java.lang.Object#equals(java.lang.Object)
-     */
-    public boolean equals(Object other) {
-        if (!(other instanceof NodeContextPath)) {
-            return false;
-        }
-        return equals((NodeContextPath) other);
-    }
-
-    /**
-     * (non-Javadoc)
-     * 
-     * @see java.lang.Object#hashCode()
-     */
-    public int hashCode() {
-        if (hash == 0) {
-            hash = hashCode0();
-        }
-        return hash;
-    }
-
-    /**
-     * Returns a hash code computed from the hash codes of the segments, using
-     * the given comparer to compute the hash codes of the segments.
-     * 
-     * @param comparer
-     *            comparer to use or <code>null</code> if the segments' hash
-     *            codes should be computed by calling their hashCode() methods.
-     * @return the computed hash code
-     */
-    private int hashCode0() {
-        int result = 0;
-        for (int i = 0; i < segments.length; i++) {
-            result += segments[i].hashCode();
-        }
-        return result;
-    }
-
-    /**
-     * Returns whether this path is equivalent to the given path using the
-     * specified comparer to compare individual elements.
-     * 
-     * @param otherPath
-     *            tree path to compare to
-     * @param comparer
-     *            comparator to use or <code>null</code> if segments should be
-     *            compared using equals()
-     * @return whether the paths are equal
-     */
-    public boolean equals(NodeContextPath otherPath) {
-        if (otherPath == null) {
-            return false;
-        }
-        if (segments.length != otherPath.segments.length) {
-            return false;
-        }
-        for (int i = 0; i < segments.length; i++) {
-            if (!segments[i].equals(otherPath.segments[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Returns whether this path starts with the same segments as the given
-     * path, using the given comparer to compare segments.
-     * 
-     * @param treePath
-     *            path to compare to
-     * @param comparer
-     *            the comparer to use, or <code>null</code> if equals() should
-     *            be used to compare segments
-     * @return whether the given path is a prefix of this path, or the same as
-     *         this path
-     */
-    public boolean startsWith(NodeContextPath treePath) {
-        int thisSegmentCount = getSegmentCount();
-        int otherSegmentCount = treePath.getSegmentCount();
-        if (otherSegmentCount == thisSegmentCount) {
-            return equals(treePath);
-        }
-        if (otherSegmentCount > thisSegmentCount) {
-            return false;
-        }
-        for (int i = 0; i < otherSegmentCount; i++) {
-            Object otherSegment = treePath.getSegment(i);
-            if (!otherSegment.equals(segments[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Returns a copy of this tree path with one segment removed from the end,
-     * or <code>null</code> if this tree path has no segments.
-     * @return a tree path
-     */
-    public NodeContextPath getParentPath() {
-        int segmentCount = getSegmentCount();
-        if (segmentCount < 1) {
-            return null;
-        } else if (segmentCount == 1) {
-            return EMPTY;
-        }
-        NodeContext[] parentSegments = new NodeContext[segmentCount - 1];
-        System.arraycopy(segments, 0, parentSegments, 0, segmentCount - 1);
-        return new NodeContextPath(parentSegments);
-    }
-
-    /**
-     * Returns a copy of this tree path with the given segment added at the end.
-     * @param newSegment 
-     * @return a tree path
-     */
-    public NodeContextPath createChildPath(NodeContext newSegment) {
-        int segmentCount = getSegmentCount();
-        NodeContext[] childSegments = new NodeContext[segmentCount + 1];
-        if(segmentCount>0) {
-            System.arraycopy(segments, 0, childSegments, 0, segmentCount);
-        }
-        childSegments[segmentCount] = newSegment;
-        return new NodeContextPath(childSegments);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <T> T getAdapter(Class<T> adapter) {
-        if (NodeContext.class == adapter)
-            return (T) getLastSegment();
-        NodeContext last = getLastSegment();
-        if (last instanceof IAdaptable)
-            return ((IAdaptable) last).getAdapter(adapter);
-        return null;
-    }
-
-}
+/*******************************************************************************
+ * Copyright (c) 2005, 2007 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.simantics.browsing.ui;
+
+import java.util.Arrays;
+
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.IAdaptable;
+
+/**
+ * A {@link GraphExplorer} tree {@link NodeContext} path denotes a model element
+ * in a tree viewer. Tree path objects have value semantics. A model element is
+ * represented by a path of elements in the tree from the root element to the
+ * leaf element.
+ * <p>
+ * Clients may instantiate this class. Not intended to be subclassed.
+ * </p>
+ * 
+ * <p>
+ * Directly imitated for the Simantics browsing framework from JFace
+ * <code>org.eclipse.jface.viewer.TreePath</code> class.
+ * </p>
+ * 
+ * @author Tuukka Lehtonen
+ */
+public final class NodeContextPath implements IAdaptable {
+
+    public static final NodeContextPath[] NONE  = {};
+
+    /**
+     * Constant for representing an empty tree path.
+     */
+    public static final NodeContextPath   EMPTY = new NodeContextPath(NodeContext.NONE);
+
+    private final NodeContext[]           segments;
+
+    private int                           hash;
+
+    /**
+     * Constructs a path identifying a leaf node in a tree.
+     * 
+     * @param segments
+     *            path of elements to a leaf node in a tree, starting with the
+     *            root element
+     */
+    public NodeContextPath(NodeContext... segments) {
+        Assert.isNotNull(segments);
+        for (int i = 0; i < segments.length; i++) {
+            Assert.isNotNull(segments[i]);
+        }
+        this.segments = segments;
+    }
+
+    /**
+     * Returns the element at the specified index in this path.
+     * 
+     * @param index
+     *            index of element to return
+     * @return element at the specified index
+     */
+    public NodeContext getSegment(int index) {
+        return segments[index];
+    }
+
+    /**
+     * Returns the number of elements in this path.
+     * 
+     * @return the number of elements in this path
+     */
+    public int getSegmentCount() {
+        return segments.length;
+    }
+
+    /**
+     * Returns the first element in this path, or <code>null</code> if this
+     * path has no segments.
+     * 
+     * @return the first element in this path
+     */
+    public NodeContext getFirstSegment() {
+        if (segments.length == 0) {
+            return null;
+        }
+        return segments[0];
+    }
+
+    /**
+     * Returns the last element in this path, or <code>null</code> if this
+     * path has no segments.
+     * 
+     * @return the last element in this path
+     */
+    public NodeContext getLastSegment() {
+        if (segments.length == 0) {
+            return null;
+        }
+        return segments[segments.length - 1];
+    }
+
+    /**
+     * @return all the segments in the path as an array
+     */
+    public NodeContext[] getSegments() {
+        if (segments.length == 0)
+            return segments;
+        return Arrays.copyOf(segments, segments.length);
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object other) {
+        if (!(other instanceof NodeContextPath)) {
+            return false;
+        }
+        return equals((NodeContextPath) other);
+    }
+
+    /**
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#hashCode()
+     */
+    public int hashCode() {
+        if (hash == 0) {
+            hash = hashCode0();
+        }
+        return hash;
+    }
+
+    /**
+     * Returns a hash code computed from the hash codes of the segments, using
+     * the given comparer to compute the hash codes of the segments.
+     * 
+     * @param comparer
+     *            comparer to use or <code>null</code> if the segments' hash
+     *            codes should be computed by calling their hashCode() methods.
+     * @return the computed hash code
+     */
+    private int hashCode0() {
+        int result = 0;
+        for (int i = 0; i < segments.length; i++) {
+            result += segments[i].hashCode();
+        }
+        return result;
+    }
+
+    /**
+     * Returns whether this path is equivalent to the given path using the
+     * specified comparer to compare individual elements.
+     * 
+     * @param otherPath
+     *            tree path to compare to
+     * @param comparer
+     *            comparator to use or <code>null</code> if segments should be
+     *            compared using equals()
+     * @return whether the paths are equal
+     */
+    public boolean equals(NodeContextPath otherPath) {
+        if (otherPath == null) {
+            return false;
+        }
+        if (segments.length != otherPath.segments.length) {
+            return false;
+        }
+        for (int i = 0; i < segments.length; i++) {
+            if (!segments[i].equals(otherPath.segments[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns whether this path starts with the same segments as the given
+     * path, using the given comparer to compare segments.
+     * 
+     * @param treePath
+     *            path to compare to
+     * @param comparer
+     *            the comparer to use, or <code>null</code> if equals() should
+     *            be used to compare segments
+     * @return whether the given path is a prefix of this path, or the same as
+     *         this path
+     */
+    public boolean startsWith(NodeContextPath treePath) {
+        int thisSegmentCount = getSegmentCount();
+        int otherSegmentCount = treePath.getSegmentCount();
+        if (otherSegmentCount == thisSegmentCount) {
+            return equals(treePath);
+        }
+        if (otherSegmentCount > thisSegmentCount) {
+            return false;
+        }
+        for (int i = 0; i < otherSegmentCount; i++) {
+            Object otherSegment = treePath.getSegment(i);
+            if (!otherSegment.equals(segments[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns a copy of this tree path with one segment removed from the end,
+     * or <code>null</code> if this tree path has no segments.
+     * @return a tree path
+     */
+    public NodeContextPath getParentPath() {
+        int segmentCount = getSegmentCount();
+        if (segmentCount < 1) {
+            return null;
+        } else if (segmentCount == 1) {
+            return EMPTY;
+        }
+        NodeContext[] parentSegments = new NodeContext[segmentCount - 1];
+        System.arraycopy(segments, 0, parentSegments, 0, segmentCount - 1);
+        return new NodeContextPath(parentSegments);
+    }
+
+    /**
+     * Returns a copy of this tree path with the given segment added at the end.
+     * @param newSegment 
+     * @return a tree path
+     */
+    public NodeContextPath createChildPath(NodeContext newSegment) {
+        int segmentCount = getSegmentCount();
+        NodeContext[] childSegments = new NodeContext[segmentCount + 1];
+        if(segmentCount>0) {
+            System.arraycopy(segments, 0, childSegments, 0, segmentCount);
+        }
+        childSegments[segmentCount] = newSegment;
+        return new NodeContextPath(childSegments);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> T getAdapter(Class<T> adapter) {
+        if (NodeContext.class == adapter)
+            return (T) getLastSegment();
+        NodeContext last = getLastSegment();
+        if (last instanceof IAdaptable)
+            return ((IAdaptable) last).getAdapter(adapter);
+        return null;
+    }
+
+}