< prev index next >

src/java.desktop/share/classes/sun/java2d/Spans.java

Print this page

        

@@ -39,22 +39,22 @@
 public class Spans {
 
     /**
      * This class will sort and collapse its span
      * entries after this many span additions via
-     * the <code>add</code> method.
+     * the {@code add} method.
      */
     private static final int kMaxAddsSinceSort = 256;
 
     /**
      * Holds a list of individual
      * Span instances.
      */
     private List<Span> mSpans = new Vector<>(kMaxAddsSinceSort);
 
     /**
-     * The number of <code>Span</code>
+     * The number of {@code Span}
      * instances that have been added
      * to this object without a sort
      * and collapse taking place.
      */
     private int mAddsSinceSort = 0;

@@ -63,12 +63,12 @@
 
     }
 
     /**
      * Add a span covering the half open interval
-     * including <code>start</code> up to
-     * but not including <code>end</code>.
+     * including {@code start} up to
+     * but not including {@code end}.
      */
     public void add(float start, float end) {
 
         if (mSpans != null) {
             mSpans.add(new Span(start, end));

@@ -80,24 +80,24 @@
     }
 
     /**
      * Add a span which covers the entire range.
      * This call is logically equivalent to
-     * <code>add(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY)</code>
+     * {@code add(Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY)}
      * The result of making this call is that
-     * all future <code>add</code> calls are ignored
-     * and the <code>intersects</code> method always
+     * all future {@code add} calls are ignored
+     * and the {@code intersects} method always
      * returns true.
      */
     public void addInfinite() {
         mSpans = null;
     }
 
     /**
      * Returns true if the span defined by the half-open
-     * interval from <code>start</code> up to,
-     * but not including, <code>end</code> intersects
+     * interval from {@code start} up to,
+     * but not including, {@code end} intersects
      * any of the spans defined by this instance.
      */
     public boolean intersects(float start, float end) {
         boolean doesIntersect;
 

@@ -229,58 +229,58 @@
          */
         private float mEnd;
 
         /**
          * Create a half-open interval including
-         * <code>start</code> but not including
-         * <code>end</code>.
+         * {@code start} but not including
+         * {@code end}.
          */
         Span(float start, float end) {
             mStart = start;
             mEnd = end;
         }
 
         /**
-         * Return the start of the <code>Span</code>.
+         * Return the start of the {@code Span}.
          * The start is considered part of the
          * half-open interval.
          */
         final float getStart() {
             return mStart;
         }
 
         /**
-         * Return the end of the <code>Span</code>.
+         * Return the end of the {@code Span}.
          * The end is not considered part of the
          * half-open interval.
          */
         final float getEnd() {
             return mEnd;
         }
 
         /**
          * Change the initial position of the
-         * <code>Span</code>.
+         * {@code Span}.
          */
         final void setStart(float start) {
             mStart = start;
         }
 
         /**
          * Change the terminal position of the
-         * <code>Span</code>.
+         * {@code Span}.
          */
         final void setEnd(float end) {
             mEnd = end;
         }
 
         /**
-         * Attempt to alter this <code>Span</code>
-         * to include <code>otherSpan</code> without
+         * Attempt to alter this {@code Span}
+         * to include {@code otherSpan} without
          * altering this span's starting position.
-         * If <code>otherSpan</code> can be so consumed
-         * by this <code>Span</code> then <code>true</code>
+         * If {@code otherSpan} can be so consumed
+         * by this {@code Span} then {@code true}
          * is returned.
          */
         boolean subsume(Span otherSpan) {
 
             /* We can only subsume 'otherSpan' if

@@ -302,11 +302,11 @@
         }
 
         /**
          * Return true if the passed in position
          * lies in the half-open interval defined
-         * by this <code>Span</code>.
+         * by this {@code Span}.
          */
         boolean contains(float pos) {
             return mStart <= pos && pos < mEnd;
         }
 

@@ -335,15 +335,15 @@
         }
 
     }
 
     /**
-     * This class ranks a pair of <code>Span</code>
+     * This class ranks a pair of {@code Span}
      * instances. If the instances intersect they
      * are deemed equal otherwise they are ranked
      * by their relative position. Use
-     * <code>SpanIntersection.instance</code> to
+     * {@code SpanIntersection.instance} to
      * get the single instance of this class.
      */
     static class SpanIntersection implements Comparator<Span> {
 
         /**
< prev index next >