libjava/javax/swing/tree/TreePath.java

   1 /* TreePath.java --
   2    Copyright (C) 2002 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.tree;
  40
  41 import java.io.IOException;
  42 import java.io.ObjectInputStream;
  43 import java.io.ObjectOutputStream;
  44 import java.io.Serializable;
  45
  46 /**
  47  * TreePath
  48  * @author Andrew Selkirk
  49  */
  50 public class TreePath implements Serializable
  51 {
  52   static final long serialVersionUID = 4380036194768077479L;
  53
  54         //-------------------------------------------------------------
  55         // Variables --------------------------------------------------
  56         //-------------------------------------------------------------
  57
  58         /**
  59          * path
  60          */
  61         private Object[]        path    = null;
  62
  63
  64         //-------------------------------------------------------------
  65         // Initialization ---------------------------------------------
  66         //-------------------------------------------------------------
  67
  68         /**
  69          * Constructor TreePath
  70          * @param path TODO
  71          */
  72         public TreePath(Object[] path) {
  73
  74                 // Create Path
  75                 this.path = new Object[path.length];
  76                 System.arraycopy(path, 0, this.path, 0, path.length);
  77
  78         } // TreePath()
  79
  80         /**
  81          * Constructor TreePath
  82          * @param element TODO
  83          */
  84         public TreePath(Object element) {
  85
  86                 // Create Path
  87                 path = new Object[1];
  88                 path[0] = element;
  89
  90         } // TreePath()
  91
  92         /**
  93          * Constructor TreePath
  94          * @param path TODO
  95          * @param element TODO
  96          */
  97         protected TreePath(TreePath path, Object element) {
  98
  99                 // Variables
 100                 Object[]        treepath;
 101
 102                 // Get Tree Path
 103                 treepath = path.getPath();
 104
 105                 // Create Tree Path
 106                 this.path = new Object[treepath.length + 1];
 107                 System.arraycopy(treepath, 0, this.path, 0, treepath.length);
 108                 this.path[treepath.length] = element;
 109
 110         } // TreePath()
 111
 112         /**
 113          * Constructor TreePath
 114          * @param path TODO
 115          * @param length TODO
 116          */
 117         protected TreePath(Object[] path, int length) {
 118
 119                 // Create Path
 120                 this.path = new Object[length];
 121                 System.arraycopy(path, 0, this.path, 0, length);
 122
 123         } // TreePath()
 124
 125         /**
 126          * Constructor TreePath
 127          */
 128         protected TreePath() {
 129                 path = new Object[0];
 130         } // TreePath()
 131
 132
 133         //-------------------------------------------------------------
 134         // Methods ----------------------------------------------------
 135         //-------------------------------------------------------------
 136
 137         /**
 138          * hashCode
 139          * @returns int
 140          */
 141         public int hashCode() {
 142                 return getLastPathComponent().hashCode();
 143         } // hashCode()
 144
 145         /**
 146          * equals
 147          * @param object TODO
 148          * @returns boolean
 149          */
 150         public boolean equals(Object object) {
 151
 152                 // Variables
 153                 Object[]        treepath;
 154                 int                     index;
 155
 156                 // Check for TreePath
 157                 if (object instanceof TreePath) {
 158
 159                         // Get Path Elements
 160                         treepath = ((TreePath) object).getPath();
 161
 162                         // Check length
 163                         if (treepath.length != path.length) {
 164                                 return false;
 165                         } // if
 166
 167                         // Check Elements
 168                         for (index = 0; index < path.length; index++) {
 169                                 if (treepath[index] != path[index]) {
 170                                         return false;
 171                                 } // if
 172                         } // for
 173
 174                         // Tree Path's are equals
 175                         return true;
 176
 177                 } // if
 178
 179                 // Unequal
 180                 return false;
 181
 182         } // equals()
 183
 184         /**
 185          * toString
 186          * @returns String
 187          */
 188         public String toString() {
 189                 return null; // TODO
 190         } // toString()
 191
 192         /**
 193          * writeObject
 194          * @param value0 TODO
 195          * @exception IOException TODO
 196          */
 197         private void writeObject(ObjectOutputStream value0) throws IOException {
 198                 // TODO
 199         } // writeObject()
 200
 201         /**
 202          * readObject
 203          * @param value0 TODO
 204          * @exception IOException TODO
 205          * @exception ClassNotFoundException TODO
 206          */
 207         private void readObject(ObjectInputStream value0) throws IOException, ClassNotFoundException {
 208                 // TODO
 209         } // readObject()
 210
 211         /**
 212          * getPath
 213          * @returns Object[]
 214          */
 215         public Object[] getPath() {
 216                 return path;
 217         } // getPath()
 218
 219         /**
 220          * getLastPathComponent
 221          * @returns Object
 222          */
 223         public Object getLastPathComponent() {
 224                 return path[path.length - 1];
 225         } // getLastPathComponent()
 226
 227         /**
 228          * getPathCount
 229          * @returns int
 230          */
 231         public int getPathCount() {
 232                 return path.length;
 233         } // getPathCount()
 234
 235         /**
 236          * getPathComponent
 237          * @param position TODO
 238          * @returns Object
 239          */
 240         public Object getPathComponent(int position) {
 241                 return path[position];
 242         } // getPathComponent()
 243
 244         /**
 245          * isDescendant
 246          * @param path TODO
 247          * @returns boolean
 248          */
 249         public boolean isDescendant(TreePath path) {
 250
 251                 // Variables
 252                 Object[]        treepath;
 253                 int                     index;
 254                 int                     index2;
 255
 256                 // Get Descendant path
 257                 treepath = path.getPath();
 258
 259                 // Locate Start Index
 260                 index = 0;
 261                 index2 = 0;
 262                 while (treepath[index] != this.path[index2]) {
 263                         index++;
 264                 } // while
 265
 266                 // Verify Paths
 267                 while (treepath[index] == this.path[index2]) {
 268                         index++;
 269                         index2++;
 270                 } // while
 271
 272                 // Check for descendant
 273                 if (index2 != this.path.length) {
 274                         return false;
 275                 } // if
 276
 277                 // Is Descendant
 278                 return true;
 279
 280         } // isDescendant()
 281
 282         /**
 283          * pathByAddingChild
 284          * @param element TODO
 285          * @returns TreePath
 286          */
 287         public TreePath pathByAddingChild(Object element) {
 288                 return new TreePath(this, element);
 289         } // pathByAddingChild()
 290
 291         /**
 292          * getParentPath
 293          * @returns TreePath
 294          */
 295         public TreePath getParentPath() {
 296                 return new TreePath(this.getPath(), path.length - 1);
 297         } // getParentPath()
 298
 299
 300 } // TreePath