You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by sc...@apache.org on 2003/08/31 15:07:27 UTC

cvs commit: jakarta-commons/collections/src/java/org/apache/commons/collections SequencedHashMap.java StaticBucketMap.java TransformerUtils.java ReferenceMap.java

scolebourne    2003/08/31 06:07:27

  Modified:    collections/src/java/org/apache/commons/collections
                        SequencedHashMap.java StaticBucketMap.java
                        TransformerUtils.java ReferenceMap.java
  Log:
  Javadoc spelling mistakes
  bug 22843, from Janek Bogucki
  
  Revision  Changes    Path
  1.18      +10 -10    jakarta-commons/collections/src/java/org/apache/commons/collections/SequencedHashMap.java
  
  Index: SequencedHashMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/SequencedHashMap.java,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- SequencedHashMap.java	16 May 2003 14:58:42 -0000	1.17
  +++ SequencedHashMap.java	31 Aug 2003 13:07:26 -0000	1.18
  @@ -108,7 +108,7 @@
           // difficult.  If a shallow clone is implemented, then entry.next.prev !=
           // entry, which is unintuitive and probably breaks all sorts of assumptions
           // in code that uses this implementation.  If a deep clone is
  -        // implementated, then what happens when the linked list is cyclical (as is
  +        // implemented, then what happens when the linked list is cyclical (as is
           // the case with SequencedHashMap)?  It's impossible to know in the clone
           // when to stop cloning, and thus you end up in a recursive loop,
           // continuously cloning the "next" in the list.
  @@ -170,7 +170,7 @@
   
       /**
        *  Construct an empty sentinel used to hold the head (sentinel.next) and the
  -     *  tail (sentinel.prev) of the list.  The sentinal has a <code>null</code>
  +     *  tail (sentinel.prev) of the list.  The sentinel has a <code>null</code>
        *  key and value.
        **/
       private static final Entry createSentinel() {
  @@ -363,7 +363,7 @@
           // does not need to be tested.  In cases where the list is empty,
           // sentinel.next will point to the sentinel itself which has a null key,
           // which is exactly what we would want to return if the list is empty (a
  -        // nice convient way to avoid test for an empty list)
  +        // nice convenient way to avoid test for an empty list)
           return sentinel.next.getKey();
       }
   
  @@ -383,7 +383,7 @@
           // list does not need to be tested.  In cases where the list is empty,
           // sentinel.next will point to the sentinel itself which has a null value,
           // which is exactly what we would want to return if the list is empty (a
  -        // nice convient way to avoid test for an empty list)
  +        // nice convenient way to avoid test for an empty list)
           return sentinel.next.getValue();
       }
   
  @@ -430,7 +430,7 @@
           // does not need to be tested.  In cases where the list is empty,
           // sentinel.prev will point to the sentinel itself which has a null key,
           // which is exactly what we would want to return if the list is empty (a
  -        // nice convient way to avoid test for an empty list)
  +        // nice convenient way to avoid test for an empty list)
           return sentinel.prev.getKey();
       }
   
  @@ -450,7 +450,7 @@
           // list does not need to be tested.  In cases where the list is empty,
           // sentinel.prev will point to the sentinel itself which has a null value,
           // which is exactly what we would want to return if the list is empty (a
  -        // nice convient way to avoid test for an empty list)
  +        // nice convenient way to avoid test for an empty list)
           return sentinel.prev.getValue();
       }
   
  @@ -974,7 +974,7 @@
        * @return the index, or -1 if not found
        */
       public int lastIndexOf(Object key) {
  -        // keys in a map are guarunteed to be unique
  +        // keys in a map are guaranteed to be unique
           return indexOf(key);
       }
   
  @@ -1006,7 +1006,7 @@
        * Removes the element at the specified index.
        *
        * @param index The index of the object to remove.
  -     * @return      The previous value coressponding the <code>key</code>, or
  +     * @return      The previous value corresponding the <code>key</code>, or
        *              <code>null</code> if none existed.
        *
        * @throws ArrayIndexOutOfBoundsException if the <code>index</code> is
  
  
  
  1.11      +5 -5      jakarta-commons/collections/src/java/org/apache/commons/collections/StaticBucketMap.java
  
  Index: StaticBucketMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/StaticBucketMap.java,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- StaticBucketMap.java	20 Jun 2003 07:59:59 -0000	1.10
  +++ StaticBucketMap.java	31 Aug 2003 13:07:26 -0000	1.11
  @@ -695,9 +695,9 @@
   
   
       /**
  -     *  Prevents any operations from occuring on this map while the
  +     *  Prevents any operations from occurring on this map while the
        *  given {@link Runnable} executes.  This method can be used, for
  -     *  instance, to execute a bulk operation atomicly: 
  +     *  instance, to execute a bulk operation atomically: 
        *
        *  <pre>
        *    staticBucketMapInstance.atomic(new Runnable() {
  @@ -726,7 +726,7 @@
        *  in your map, then the recursive method will be invoked twenty thousand
        *  times.  You have been warned.
        *
  -     *  @param r  the code to execute atomicly
  +     *  @param r  the code to execute atomically
        */
       public void atomic(Runnable r) {
           if (r == null) throw new NullPointerException();
  
  
  
  1.2       +3 -3      jakarta-commons/collections/src/java/org/apache/commons/collections/TransformerUtils.java
  
  Index: TransformerUtils.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/TransformerUtils.java,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- TransformerUtils.java	16 May 2003 13:41:10 -0000	1.1
  +++ TransformerUtils.java	31 Aug 2003 13:07:26 -0000	1.2
  @@ -403,7 +403,7 @@
           Transformer[] trs = null;
           Predicate[] preds = null;
           if (objectsAndTransformers == null) {
  -            throw new IllegalArgumentException("The obejct and transformer map must not be null");
  +            throw new IllegalArgumentException("The object and transformer map must not be null");
           }
           Transformer def = (Transformer) objectsAndTransformers.remove(null);
           int size = objectsAndTransformers.size();
  
  
  
  1.13      +3 -3      jakarta-commons/collections/src/java/org/apache/commons/collections/ReferenceMap.java
  
  Index: ReferenceMap.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/collections/src/java/org/apache/commons/collections/ReferenceMap.java,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- ReferenceMap.java	16 May 2003 14:58:42 -0000	1.12
  +++ ReferenceMap.java	31 Aug 2003 13:07:26 -0000	1.13
  @@ -135,7 +135,7 @@
   
   
       /**
  -     *  Constant indiciating that soft references should be used.
  +     *  Constant indicating that soft references should be used.
        */
       final public static int SOFT = 1;