Aprog/src/net/sourceforge/aprog/tools/WeakBag.java

   1 /*
   2  *  The MIT License
   3  *
   4  *  Copyright 2010 Codist Monk.
   5  *
   6  *  Permission is hereby granted, free of charge, to any person obtaining a copy
   7  *  of this software and associated documentation files (the "Software"), to deal
   8  *  in the Software without restriction, including without limitation the rights
   9  *  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  *  copies of the Software, and to permit persons to whom the Software is
  11  *  furnished to do so, subject to the following conditions:
  12  *
  13  *  The above copyright notice and this permission notice shall be included in
  14  *  all copies or substantial portions of the Software.
  15  *
  16  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  *  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  *  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  *  THE SOFTWARE.
  23  */
  24
  25 package net.sourceforge.aprog.tools;
  26
  27 import static net.sourceforge.aprog.tools.Tools.*;
  28
  29 import java.lang.ref.WeakReference;
  30 import java.util.Iterator;
  31 import java.util.LinkedList;
  32 import java.util.List;
  33 import java.util.logging.Level;
  34
  35 /**
  36  * Instances of this class contain weak references on their elements.
  37  * <br>Hard references are created only during iteration by {@link Iterator#hasNext()}
  38  * (to ensure that the returned element is never null),
  39  * and then removed by {@link Iterator#next()}.
  40  * <br>When elements need to be compared, the identity operator {@code ==} is used.
  41  * <br>Iteration goes through the elements in the same order they were inserted.
  42  *
  43  * @param <T> The element type
  44  * @author codistmonk (creation 2010-10-24)
  45  */
  46 public final class WeakBag<T> implements Iterable<T> {
  47
  48     private final List<WeakReference<T>> references;
  49
  50     public WeakBag() {
  51         this.references = new LinkedList<WeakReference<T>>();
  52     }
  53
  54     /**
  55      *
  56      * @param element
  57      * <br>Not null
  58      * <br>Shared
  59      */
  60     public final void append(final T element) {
  61         this.getReferences().add(new WeakReference<T>(element));
  62     }
  63
  64     /**
  65      *
  66      * @param element
  67      * <br>Maybe null
  68      */
  69     public final void remove(final T element) {
  70         for (final Iterator<T> i = this.iterator(); i.hasNext();) {
  71             if (i.next() == element) {
  72                 i.remove();
  73             }
  74         }
  75     }
  76
  77     /**
  78      *
  79      * @return
  80      * <br>Range: {@code [0 .. Integer.MAX_VALUE]}
  81      */
  82     public final int getElementCount() {
  83         int result = 0;
  84
  85         for (final T element : this) {
  86             if (element != null) {
  87                 ++result;
  88             }
  89         }
  90
  91         return result;
  92     }
  93
  94     /**
  95      *
  96      * @return
  97      * <br>Range: any boolean
  98      */
  99     public final boolean isEmpty() {
 100         return 0 == this.getElementCount();
 101     }
 102
 103     @Override
 104     public final Iterator<T> iterator() {
 105         return this.new WeakIterator();
 106     }
 107
 108     /**
 109      *
 110      * @return
 111      * <br>Not null
 112      * <br>Shared
 113      */
 114     final List<WeakReference<T>> getReferences() {
 115         return this.references;
 116     }
 117
 118     /**
 119      * @author codistmonk (creation 2010-10-24)
 120      */
 121     private final class WeakIterator implements Iterator<T> {
 122
 123         private final Iterator<WeakReference<T>> iterator;
 124
 125         private T next;
 126
 127         public WeakIterator() {
 128             this.iterator = WeakBag.this.getReferences().iterator();
 129         }
 130
 131         @Override
 132         public final boolean hasNext() {
 133             while (this.next == null && this.iterator.hasNext()) {
 134                 this.next = this.iterator.next().get();
 135
 136                 if (this.next == null) {
 137                     this.iterator.remove();
 138                 }
 139             }
 140
 141             return this.next != null;
 142         }
 143
 144         @Override
 145         public final T next() {
 146             final T result = this.next;
 147             this.next = null;
 148
 149             return result;
 150         }
 151
 152         @Override
 153         public final void remove() {
 154             this.iterator.remove();
 155         }
 156
 157     }
 158
 159     /**
 160      * {@value} milliseconds.
 161      */
 162     public static final long GARBAGE_COLLECTOR_TIME = 100L;
 163
 164     /**
 165      * Calls {@link System#gc()} and then waits for {@link #GARBAGE_COLLECTOR_TIME} milliseconds.
 166      * <br>This method should only be used for testing.
 167      * <br>Due to the unpredictable nature of the garbage collector, it may or may not have
 168      * finished its work at the end of the wait.
 169      */
 170     public static final void runGarbageCollector() {
 171         System.gc();
 172
 173         try {
 174             // Give some time to the garbage collector to do its work
 175             Thread.sleep(GARBAGE_COLLECTOR_TIME);
 176         } catch (final InterruptedException exception) {
 177             getLoggerForThisMethod().log(Level.WARNING, null, exception);
 178         }
 179     }
 180
 181 }