Import GNU Classpath (20121202).

2012-12-19  Matthias Klose  <doko@ubuntu.com>

        Import GNU Classpath (20121202).

        * Regenerate class and header files.
        * Regenerate auto* files.
        * sources.am, gcj/javaprims.h: Regenerate.
        * gnu/java/nio/FileLockImpl.java (close): New override.

From-SVN: r194618

1 files changed, 106 insertions, 120 deletions

diff --git a/libjava/classpath/java/awt/geom/Area.java b/libjava/classpath/java/awt/geom/Area.java
index a1eaf63..51f914f 100644
--- a/libjava/classpath/java/awt/geom/Area.java
+++ b/libjava/classpath/java/awt/geom/Area.java
@@ -91,18 +91,18 @@ public class Area implements Shape, Cloneable
    * Segment vectors containing solid areas and holes
    * This is package-private to avoid an accessor method.
    */
-  Vector solids;
+  Vector<Segment> solids;
 
   /**
    * Segment vectors containing solid areas and holes
    * This is package-private to avoid an accessor method.
    */
-  Vector holes;
+  Vector<Segment> holes;
 
   /**
    * Vector (temporary) storing curve-curve intersections
    */
-  private Vector cc_intersections;
+  private Vector<double[]> ccIntersections;
 
   /**
    * Winding rule WIND_NON_ZERO used, after construction,
@@ -115,8 +115,8 @@ public class Area implements Shape, Cloneable
    */
   public Area()
   {
-    solids = new Vector();
-    holes = new Vector();
+    solids = new Vector<Segment>();
+    holes = new Vector<Segment>();
   }
 
   /**
@@ -135,7 +135,7 @@ public class Area implements Shape, Cloneable
   {
     this();
 
-    Vector p = makeSegment(s);
+    Vector<Segment> p = makeSegment(s);
 
     // empty path
     if (p == null)
@@ -143,7 +143,7 @@ public class Area implements Shape, Cloneable
 
     // delete empty paths
     for (int i = 0; i < p.size(); i++)
-      if (((Segment) p.elementAt(i)).getSignedArea() == 0.0)
+      if (p.elementAt(i).getSignedArea() == 0.0)
         p.remove(i--);
 
     /*
@@ -157,12 +157,11 @@ public class Area implements Shape, Cloneable
      * 4: Repeat (3) until no segments remain in the list
      * 5: Remove redundant paths and sort into solids and holes
      */
-    Vector paths = new Vector();
     Segment v;
 
     for (int i = 0; i < p.size(); i++)
       {
-        Segment path = (Segment) p.elementAt(i);
+        Segment path = p.elementAt(i);
         createNodesSelf(path);
       }
 
@@ -171,18 +170,18 @@ public class Area implements Shape, Cloneable
         for (int i = 0; i < p.size() - 1; i++)
           for (int j = i + 1; j < p.size(); j++)
             {
-              Segment path1 = (Segment) p.elementAt(i);
-              Segment path2 = (Segment) p.elementAt(j);
+              Segment path1 = p.elementAt(i);
+              Segment path2 = p.elementAt(j);
               createNodes(path1, path2);
             }
       }
 
     // we have intersecting points.
-    Vector segments = new Vector();
+    Vector<Segment> segments = new Vector<Segment>();
 
     for (int i = 0; i < p.size(); i++)
       {
-        Segment path = v = (Segment) p.elementAt(i);
+        Segment path = v = p.elementAt(i);
         do
           {
             segments.add(v);
@@ -191,7 +190,7 @@ public class Area implements Shape, Cloneable
         while (v != path);
       }
 
-    paths = weilerAtherton(segments);
+    Vector<Segment> paths = weilerAtherton(segments);
     deleteRedundantPaths(paths);
   }
 
@@ -208,36 +207,34 @@ public class Area implements Shape, Cloneable
 
     Area B = (Area) area.clone();
 
-    Vector pathA = new Vector();
-    Vector pathB = new Vector();
+    Vector<Segment> pathA = new Vector<Segment>();
+    Vector<Segment> pathB = new Vector<Segment>();
     pathA.addAll(solids);
     pathA.addAll(holes);
     pathB.addAll(B.solids);
     pathB.addAll(B.holes);
 
-    int nNodes = 0;
-
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment a = (Segment) pathA.elementAt(i);
+        Segment a = pathA.elementAt(i);
         for (int j = 0; j < pathB.size(); j++)
           {
-            Segment b = (Segment) pathB.elementAt(j);
-            nNodes += createNodes(a, b);
+            Segment b = pathB.elementAt(j);
+            createNodes(a, b);
           }
       }
 
-    Vector paths = new Vector();
+    Vector<Segment> paths = new Vector<Segment>();
     Segment v;
 
     // we have intersecting points.
-    Vector segments = new Vector();
+    Vector<Segment> segments = new Vector<Segment>();
 
     // In a union operation, we keep all
     // segments of A oustide B and all B outside A
     for (int i = 0; i < pathA.size(); i++)
       {
-        v = (Segment) pathA.elementAt(i);
+        v = pathA.elementAt(i);
         Segment path = v;
         do
           {
@@ -250,7 +247,7 @@ public class Area implements Shape, Cloneable
 
     for (int i = 0; i < pathB.size(); i++)
       {
-        v = (Segment) pathB.elementAt(i);
+        v = pathB.elementAt(i);
         Segment path = v;
         do
           {
@@ -281,7 +278,7 @@ public class Area implements Shape, Cloneable
         return;
       }
 
-    Vector pathA = new Vector();
+    Vector<Segment> pathA = new Vector<Segment>();
     Area B = (Area) area.clone();
     pathA.addAll(solids);
     pathA.addAll(holes);
@@ -290,27 +287,23 @@ public class Area implements Shape, Cloneable
     setDirection(B.holes, true);
     setDirection(B.solids, false);
 
-    Vector pathB = new Vector();
+    Vector<Segment> pathB = new Vector<Segment>();
     pathB.addAll(B.solids);
     pathB.addAll(B.holes);
 
-    int nNodes = 0;
-
     // create nodes
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment a = (Segment) pathA.elementAt(i);
+        Segment a = pathA.elementAt(i);
         for (int j = 0; j < pathB.size(); j++)
           {
-            Segment b = (Segment) pathB.elementAt(j);
-            nNodes += createNodes(a, b);
+            Segment b = pathB.elementAt(j);
+            createNodes(a, b);
           }
       }
 
-    Vector paths = new Vector();
-
     // we have intersecting points.
-    Vector segments = new Vector();
+    Vector<Segment> segments = new Vector<Segment>();
 
     // In a subtraction operation, we keep all
     // segments of A oustide B and all B within A
@@ -318,7 +311,7 @@ public class Area implements Shape, Cloneable
     // and the segments before and after any node
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment v = (Segment) pathA.elementAt(i);
+        Segment v = pathA.elementAt(i);
         Segment path = v;
         if (v.isSegmentOutside(area) && v.node == null)
           segments.add(v);
@@ -357,7 +350,7 @@ public class Area implements Shape, Cloneable
         while (v != path);
       }
 
-    paths = weilerAtherton(segments);
+    Vector<Segment> paths = weilerAtherton(segments);
     deleteRedundantPaths(paths);
   }
 
@@ -376,32 +369,28 @@ public class Area implements Shape, Cloneable
     if (equals(area))
       return;
 
-    Vector pathA = new Vector();
+    Vector<Segment> pathA = new Vector<Segment>();
     Area B = (Area) area.clone();
     pathA.addAll(solids);
     pathA.addAll(holes);
 
-    Vector pathB = new Vector();
+    Vector<Segment> pathB = new Vector<Segment>();
     pathB.addAll(B.solids);
     pathB.addAll(B.holes);
 
-    int nNodes = 0;
-
     // create nodes
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment a = (Segment) pathA.elementAt(i);
+        Segment a = pathA.elementAt(i);
         for (int j = 0; j < pathB.size(); j++)
           {
-            Segment b = (Segment) pathB.elementAt(j);
-            nNodes += createNodes(a, b);
+            Segment b = pathB.elementAt(j);
+            createNodes(a, b);
           }
       }
 
-    Vector paths = new Vector();
-
     // we have intersecting points.
-    Vector segments = new Vector();
+    Vector<Segment> segments = new Vector<Segment>();
 
     // In an intersection operation, we keep all
     // segments of A within B and all B within A
@@ -410,7 +399,7 @@ public class Area implements Shape, Cloneable
     // and the segments before and after any node
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment v = (Segment) pathA.elementAt(i);
+        Segment v = pathA.elementAt(i);
         Segment path = v;
         if (! v.isSegmentOutside(area) && v.node == null)
           segments.add(v);
@@ -430,7 +419,7 @@ public class Area implements Shape, Cloneable
 
     for (int i = 0; i < pathB.size(); i++)
       {
-        Segment v = (Segment) pathB.elementAt(i);
+        Segment v = pathB.elementAt(i);
         Segment path = v;
         if (! v.isSegmentOutside(this) && v.node == null)
           segments.add(v);
@@ -449,7 +438,7 @@ public class Area implements Shape, Cloneable
         while (v != path);
       }
 
-    paths = weilerAtherton(segments);
+    Vector<Segment> paths = weilerAtherton(segments);
     deleteRedundantPaths(paths);
   }
 
@@ -476,10 +465,10 @@ public class Area implements Shape, Cloneable
         return;
       }
 
-    Vector pathA = new Vector();
+    Vector<Segment> pathA = new Vector<Segment>();
 
     Area B = (Area) area.clone();
-    Vector pathB = new Vector();
+    Vector<Segment> pathB = new Vector<Segment>();
     pathA.addAll(solids);
     pathA.addAll(holes);
 
@@ -489,28 +478,25 @@ public class Area implements Shape, Cloneable
     pathB.addAll(B.solids);
     pathB.addAll(B.holes);
 
-    int nNodes = 0;
-
     for (int i = 0; i < pathA.size(); i++)
       {
-        Segment a = (Segment) pathA.elementAt(i);
+        Segment a = pathA.elementAt(i);
         for (int j = 0; j < pathB.size(); j++)
           {
-            Segment b = (Segment) pathB.elementAt(j);
-            nNodes += createNodes(a, b);
+            Segment b = pathB.elementAt(j);
+            createNodes(a, b);
           }
       }
 
-    Vector paths = new Vector();
     Segment v;
 
     // we have intersecting points.
-    Vector segments = new Vector();
+    Vector<Segment> segments = new Vector<Segment>();
 
     // In an XOR operation, we operate on all segments
     for (int i = 0; i < pathA.size(); i++)
       {
-        v = (Segment) pathA.elementAt(i);
+        v = pathA.elementAt(i);
         Segment path = v;
         do
           {
@@ -522,7 +508,7 @@ public class Area implements Shape, Cloneable
 
     for (int i = 0; i < pathB.size(); i++)
       {
-        v = (Segment) pathB.elementAt(i);
+        v = pathB.elementAt(i);
         Segment path = v;
         do
           {
@@ -532,7 +518,7 @@ public class Area implements Shape, Cloneable
         while (v != path);
       }
 
-    paths = weilerAtherton(segments);
+    Vector<Segment> paths = weilerAtherton(segments);
     deleteRedundantPaths(paths);
   }
 
@@ -541,8 +527,8 @@ public class Area implements Shape, Cloneable
    */
   public void reset()
   {
-    solids = new Vector();
-    holes = new Vector();
+    solids = new Vector<Segment>();
+    holes = new Vector<Segment>();
   }
 
   /**
@@ -556,9 +542,9 @@ public class Area implements Shape, Cloneable
 
     double totalArea = 0;
     for (int i = 0; i < solids.size(); i++)
-      totalArea += Math.abs(((Segment) solids.elementAt(i)).getSignedArea());
+      totalArea += Math.abs(solids.elementAt(i).getSignedArea());
     for (int i = 0; i < holes.size(); i++)
-      totalArea -= Math.abs(((Segment) holes.elementAt(i)).getSignedArea());
+      totalArea -= Math.abs(holes.elementAt(i).getSignedArea());
     if (totalArea <= EPSILON)
       return true;
 
@@ -572,10 +558,10 @@ public class Area implements Shape, Cloneable
   public boolean isPolygonal()
   {
     for (int i = 0; i < holes.size(); i++)
-      if (! ((Segment) holes.elementAt(i)).isPolygonal())
+      if (!holes.elementAt(i).isPolygonal())
         return false;
     for (int i = 0; i < solids.size(); i++)
-      if (! ((Segment) solids.elementAt(i)).isPolygonal())
+      if (!solids.elementAt(i).isPolygonal())
         return false;
     return true;
   }
@@ -599,7 +585,7 @@ public class Area implements Shape, Cloneable
     if (holes.size() != 0 || solids.size() != 1)
       return false;
 
-    Segment path = (Segment) solids.elementAt(0);
+    Segment path = solids.elementAt(0);
     if (! path.isPolygonal())
       return false;
 
@@ -657,12 +643,12 @@ public class Area implements Shape, Cloneable
     double xmax;
     double ymin;
     double ymax;
-    xmin = xmax = ((Segment) solids.elementAt(0)).P1.getX();
-    ymin = ymax = ((Segment) solids.elementAt(0)).P1.getY();
+    xmin = xmax = solids.elementAt(0).P1.getX();
+    ymin = ymax = solids.elementAt(0).P1.getY();
 
     for (int path = 0; path < solids.size(); path++)
       {
-        Rectangle2D r = ((Segment) solids.elementAt(path)).getPathBounds();
+        Rectangle2D r = solids.elementAt(path).getPathBounds();
         xmin = Math.min(r.getMinX(), xmin);
         ymin = Math.min(r.getMinY(), ymin);
         xmax = Math.max(r.getMaxX(), xmax);
@@ -696,9 +682,9 @@ public class Area implements Shape, Cloneable
       {
         Area clone = new Area();
         for (int i = 0; i < solids.size(); i++)
-          clone.solids.add(((Segment) solids.elementAt(i)).cloneSegmentList());
+          clone.solids.add(solids.elementAt(i).cloneSegmentList());
         for (int i = 0; i < holes.size(); i++)
-          clone.holes.add(((Segment) holes.elementAt(i)).cloneSegmentList());
+          clone.holes.add(holes.elementAt(i).cloneSegmentList());
         return clone;
       }
     catch (CloneNotSupportedException e)
@@ -727,10 +713,10 @@ public class Area implements Shape, Cloneable
         || holes.size() != area.holes.size())
       return false;
 
-    Vector pathA = new Vector();
+    Vector<Segment> pathA = new Vector<Segment>();
     pathA.addAll(solids);
     pathA.addAll(holes);
-    Vector pathB = new Vector();
+    Vector<Segment> pathB = new Vector<Segment>();
     pathB.addAll(area.solids);
     pathB.addAll(area.holes);
 
@@ -741,8 +727,8 @@ public class Area implements Shape, Cloneable
       {
         for (int j = 0; j < nPaths; j++)
           {
-            Segment p1 = (Segment) pathA.elementAt(i);
-            Segment p2 = (Segment) pathB.elementAt(j);
+            Segment p1 = pathA.elementAt(i);
+            Segment p2 = pathB.elementAt(j);
             if (! match[0][i] && ! match[1][j])
               if (p1.pathEquals(p2))
                 match[0][i] = match[1][j] = true;
@@ -763,9 +749,9 @@ public class Area implements Shape, Cloneable
   public void transform(AffineTransform at)
   {
     for (int i = 0; i < solids.size(); i++)
-      ((Segment) solids.elementAt(i)).transformSegmentList(at);
+      solids.elementAt(i).transformSegmentList(at);
     for (int i = 0; i < holes.size(); i++)
-      ((Segment) holes.elementAt(i)).transformSegmentList(at);
+      holes.elementAt(i).transformSegmentList(at);
 
     // Note that the orientation is not invariant under inversion
     if ((at.getType() & AffineTransform.TYPE_FLIP) != 0)
@@ -800,11 +786,11 @@ public class Area implements Shape, Cloneable
   {
     int n = 0;
     for (int i = 0; i < solids.size(); i++)
-      if (((Segment) solids.elementAt(i)).contains(x, y))
+      if (solids.elementAt(i).contains(x, y))
         n++;
 
     for (int i = 0; i < holes.size(); i++)
-      if (((Segment) holes.elementAt(i)).contains(x, y))
+      if (holes.elementAt(i).contains(x, y))
         n--;
 
     return (n != 0);
@@ -854,7 +840,7 @@ public class Area implements Shape, Cloneable
           {
             Segment v;
             Segment start;
-            start = v = (Segment) solids.elementAt(path);
+            start = v = solids.elementAt(path);
             do
               {
                 if (l[i].hasIntersections(v))
@@ -867,7 +853,7 @@ public class Area implements Shape, Cloneable
           {
             Segment v;
             Segment start;
-            start = v = (Segment) holes.elementAt(path);
+            start = v = holes.elementAt(path);
             do
               {
                 if (l[i].hasIntersections(v))
@@ -886,7 +872,7 @@ public class Area implements Shape, Cloneable
     // but encloses a hole?
     Rectangle2D r = new Rectangle2D.Double(x, y, w, h);
     for (int path = 0; path < holes.size(); path++)
-      if (! ((Segment) holes.elementAt(path)).isSegmentOutside(r))
+      if (! holes.elementAt(path).isSegmentOutside(r))
         return false;
 
     return true;
@@ -938,7 +924,7 @@ public class Area implements Shape, Cloneable
           {
             Segment v;
             Segment start;
-            start = v = (Segment) solids.elementAt(path);
+            start = v = solids.elementAt(path);
             do
               {
                 if (l[i].hasIntersections(v))
@@ -951,7 +937,7 @@ public class Area implements Shape, Cloneable
           {
             Segment v;
             Segment start;
-            start = v = (Segment) holes.elementAt(path);
+            start = v = holes.elementAt(path);
             do
               {
                 if (l[i].hasIntersections(v))
@@ -967,7 +953,7 @@ public class Area implements Shape, Cloneable
       return true;
 
     // What if the rectangle encloses the whole shape?
-    Point2D p = ((Segment) solids.elementAt(0)).getMidPoint();
+    Point2D p = solids.elementAt(0).getMidPoint();
     if ((new Rectangle2D.Double(x, y, w, h)).contains(p))
       return true;
     return false;
@@ -1020,7 +1006,7 @@ public class Area implements Shape, Cloneable
    */
   private class AreaIterator implements PathIterator
   {
-    private Vector segments;
+    private Vector<IteratorSegment> segments;
     private int index;
     private AffineTransform at;
 
@@ -1045,14 +1031,14 @@ public class Area implements Shape, Cloneable
     {
       this.at = at;
       index = 0;
-      segments = new Vector();
-      Vector allpaths = new Vector();
+      segments = new Vector<IteratorSegment>();
+      Vector<Segment> allpaths = new Vector<Segment>();
       allpaths.addAll(solids);
       allpaths.addAll(holes);
 
       for (int i = 0; i < allpaths.size(); i++)
         {
-          Segment v = (Segment) allpaths.elementAt(i);
+          Segment v = allpaths.elementAt(i);
           Segment start = v;
 
           IteratorSegment is = new IteratorSegment();
@@ -1078,7 +1064,7 @@ public class Area implements Shape, Cloneable
 
     public int currentSegment(double[] coords)
     {
-      IteratorSegment s = (IteratorSegment) segments.elementAt(index);
+      IteratorSegment s = segments.elementAt(index);
       if (at != null)
         at.transform(s.coords, 0, coords, 0, 3);
       else
@@ -1089,7 +1075,7 @@ public class Area implements Shape, Cloneable
 
     public int currentSegment(float[] coords)
     {
-      IteratorSegment s = (IteratorSegment) segments.elementAt(index);
+      IteratorSegment s = segments.elementAt(index);
       double[] d = new double[6];
       if (at != null)
         {
@@ -1129,13 +1115,13 @@ public class Area implements Shape, Cloneable
    *
    * Returns a Vector of the resulting paths.
    */
-  private Vector weilerAtherton(Vector segments)
+  private Vector<Segment> weilerAtherton(Vector<Segment> segments)
   {
-    Vector paths = new Vector();
+    Vector<Segment> paths = new Vector<Segment>();
     while (segments.size() > 0)
       {
         // Iterate over the path
-        Segment start = (Segment) segments.elementAt(0);
+        Segment start = segments.elementAt(0);
         Segment s = start;
         do
           {
@@ -1252,7 +1238,7 @@ public class Area implements Shape, Cloneable
         double[] temp = new double[2];
         temp[0] = t1 + s * w1;
         temp[1] = t2 + t * w1;
-        cc_intersections.add(temp);
+        ccIntersections.add(temp);
         return;
       }
 
@@ -1328,28 +1314,28 @@ public class Area implements Shape, Cloneable
     if (! r1.intersects(r2))
       return null;
 
-    cc_intersections = new Vector();
+    ccIntersections = new Vector<double[]>();
     recursiveSubdivide(curve1.getCubicCurve2D(), curve2.getCubicCurve2D(),
                        getRecursionDepth(curve1), getRecursionDepth(curve2),
                        0.0, 0.0, 1.0, 1.0);
 
-    if (cc_intersections.size() == 0)
+    if (ccIntersections.size() == 0)
       return null;
 
-    Intersection[] results = new Intersection[cc_intersections.size()];
-    for (int i = 0; i < cc_intersections.size(); i++)
+    Intersection[] results = new Intersection[ccIntersections.size()];
+    for (int i = 0; i < ccIntersections.size(); i++)
       {
-        double[] temp = (double[]) cc_intersections.elementAt(i);
+        double[] temp = ccIntersections.elementAt(i);
         results[i] = new Intersection(curve1.evaluatePoint(temp[0]), temp[0],
                                       temp[1]);
       }
-    cc_intersections = null;
+    ccIntersections = null;
     return (results);
   }
 
   /**
    * Returns the intersections between a line and a quadratic bezier
-   * Or null if no intersections are found1
+   * Or null if no intersections are found.
    * This is done through combining the line's equation with the
    * parametric form of the Bezier and solving the resulting quadratic.
    * This is package-private to avoid an accessor method.
@@ -1622,9 +1608,9 @@ public class Area implements Shape, Cloneable
    * Helper method
    * Turns a shape into a Vector of Segments
    */
-  private Vector makeSegment(Shape s)
+  private Vector<Segment> makeSegment(Shape s)
   {
-    Vector paths = new Vector();
+    Vector<Segment> paths = new Vector<Segment>();
     PathIterator pi = s.getPathIterator(null);
     double[] coords = new double[6];
     Segment subpath = null;
@@ -1786,7 +1772,7 @@ public class Area implements Shape, Cloneable
       }
     while (a != A); // until one wrap.
 
-    return (nNodes);
+    return nNodes;
   }
 
   /**
@@ -1824,7 +1810,7 @@ public class Area implements Shape, Cloneable
    * solid areas) Clears any nodes. Sorts the remaining paths into solids
    * and holes, sets their orientation and sets the solids and holes lists.
    */
-  private void deleteRedundantPaths(Vector paths)
+  private void deleteRedundantPaths(Vector<Segment> paths)
   {
     int npaths = paths.size();
 
@@ -1836,19 +1822,19 @@ public class Area implements Shape, Cloneable
     neg = ((windingRule == PathIterator.WIND_NON_ZERO) ? -1 : 1);
 
     for (int i = 0; i < npaths; i++)
-      bb[i] = ((Segment) paths.elementAt(i)).getPathBounds();
+      bb[i] = paths.elementAt(i).getPathBounds();
 
     // Find which path contains which, assign winding numbers
     for (int i = 0; i < npaths; i++)
       {
-        Segment pathA = (Segment) paths.elementAt(i);
+        Segment pathA = paths.elementAt(i);
         pathA.nullNodes(); // remove any now-redundant nodes, in case.
         int windingA = pathA.hasClockwiseOrientation() ? 1 : neg;
 
         for (int j = 0; j < npaths; j++)
           if (i != j)
             {
-              Segment pathB = (Segment) paths.elementAt(j);
+              Segment pathB = paths.elementAt(j);
 
               // A contains B
               if (bb[i].intersects(bb[j]))
@@ -1876,8 +1862,8 @@ public class Area implements Shape, Cloneable
         windingNumbers[i][1] = contains[i][i];
       }
 
-    Vector solids = new Vector();
-    Vector holes = new Vector();
+    Vector<Segment> solids = new Vector<Segment>();
+    Vector<Segment> holes = new Vector<Segment>();
 
     if (windingRule == PathIterator.WIND_NON_ZERO)
       {
@@ -1913,12 +1899,12 @@ public class Area implements Shape, Cloneable
    * @param clockwise gives the direction,
    * true = clockwise, false = counter-clockwise
    */
-  private void setDirection(Vector paths, boolean clockwise)
+  private void setDirection(Vector<Segment> paths, boolean clockwise)
   {
     Segment v;
     for (int i = 0; i < paths.size(); i++)
       {
-        v = (Segment) paths.elementAt(i);
+        v = paths.elementAt(i);
         if (clockwise != v.hasClockwiseOrientation())
           v.reverseAll();
       }
@@ -2157,7 +2143,7 @@ public class Area implements Shape, Cloneable
      */
     Segment cloneSegmentList() throws CloneNotSupportedException
     {
-      Vector list = new Vector();
+      Vector<Segment> list = new Vector<Segment>();
       Segment v = next;
 
       while (v != this)
@@ -2170,7 +2156,7 @@ public class Area implements Shape, Cloneable
       v = clone;
       for (int i = 0; i < list.size(); i++)
         {
-          clone.next = (Segment) ((Segment) list.elementAt(i)).clone();
+          clone.next = (Segment) list.elementAt(i).clone();
           clone = clone.next;
         }
       clone.next = v;
@@ -2209,7 +2195,7 @@ public class Area implements Shape, Cloneable
      */
     protected int createNodes(Segment b, Intersection[] x)
     {
-      Vector v = new Vector();
+      Vector<Intersection> v = new Vector<Intersection>();
       for (int i = 0; i < x.length; i++)
         {
           Point2D p = x[i].p;
@@ -2222,7 +2208,7 @@ public class Area implements Shape, Cloneable
       Intersection[] A = new Intersection[nNodes];
       Intersection[] B = new Intersection[nNodes];
       for (int i = 0; i < nNodes; i++)
-        A[i] = B[i] = (Intersection) v.elementAt(i);
+        A[i] = B[i] = v.elementAt(i);
 
       // Create two lists sorted by the parameter
       // Bubble sort, OK I suppose, since the number of intersections