fix typo and remove any extra whitespace at the end of line

Author: rubenporras

plugins/org.eclipse.emf.common/src/org/eclipse/emf/common/util/Pool.java

@@ -24,7 +24,7 @@
  * to support multiple simultaneous readers while ensuring that writes are properly serial.
  * The locks are held for the minimal period to allow maximal concurrency.
  * Removals, i.e., {@link #remove(Object) remove}, {@link #removeAll(Collection) removeAll}, {@link #clear() clear}, and {@link #retainAll(Collection) retainAll}, are not supported.
- * 
+ *
  * @since 2.9
  */
 public class Pool<E> extends WeakInterningHashSet<E>
@@ -105,25 +105,25 @@ protected abstract static class Queue<E> extends AtomicReference<AccessUnit<E>>
           @Override
           protected E getValue()
           {
-            throw new UnsupportedOperationException(); 
+            throw new UnsupportedOperationException();
           }
 
           @Override
           protected void setValue(E value)
           {
-            throw new UnsupportedOperationException(); 
+            throw new UnsupportedOperationException();
           }
 
           @Override
           protected boolean setArbitraryValue(Object value)
           {
-            throw new UnsupportedOperationException(); 
+            throw new UnsupportedOperationException();
           }
 
           @Override
-          public void reset(boolean isExclusive) 
+          public void reset(boolean isExclusive)
           {
-            throw new UnsupportedOperationException(); 
+            throw new UnsupportedOperationException();
           }
         };
 
@@ -774,7 +774,7 @@ protected final void access(boolean isReadLocked, AccessUnit<E> accessUnit)
 
     // Periodically poll the queue to clean up garbage collected entries.
     // It doesn't matter that this access count increment isn't thread safe, it just means we might take a little longer to poll the queue.
-    // Note that cleanup will acquire the write lock, so we mustn't call if if we're holding the read lock.
+    // Note that cleanup will acquire the write lock, so we mustn't call if we're holding the read lock.
     //
     if (!isReadLocked && internalQueue != null && ++accessCount == cleanupPeriod)
     {

plugins/org.eclipse.emf.common/src/org/eclipse/emf/common/util/WeakInterningHashSet.java

@@ -119,7 +119,7 @@ public class WeakInterningHashSet<E>  extends AbstractSet<E> implements Internin
   /**
    * A queue used when {@link #newExternalEntry(Object, int) creating} external entries and subsequently for cleaning garbage collected references.
    * {@link SelfCleaningEntry#clear() Cleaning} garbage collected references is the responsibility of this external queue provider.
-   * All calls to {@link #cleanup()} are guarded by whether {@link #internalQueue} value is <code>null</code>, so no cleanup takes plac when there is an external reference queue.
+   * All calls to {@link #cleanup()} are guarded by whether {@link #internalQueue} value is <code>null</code>, so no cleanup takes place when there is an external reference queue.
    */
   transient final protected ReferenceQueue<Object> externalQueue;
 
@@ -991,7 +991,7 @@ protected void putEntry(int index, Entry<E> entry)
 
   /**
    * Adds a new entry to the set at the given given index in the {@link #entries}.
-   * It {@link #ensureCapacity() ensures} the capacity is sufficient, 
+   * It {@link #ensureCapacity() ensures} the capacity is sufficient,
    * increases the {@link #size} of the set, increments the {@link #modCount},
    * and {@link #putEntry(int, Entry) puts} the entry into the set.
    */