Coverage Report - org.crosswire.jsword.passage.RocketPassage
 
Classes in this File Line Coverage Branch Coverage Complexity
RocketPassage
0%
0/52
0%
0/18
2.2
 
 1  
 /**
 2  
  * Distribution License:
 3  
  * JSword is free software; you can redistribute it and/or modify it under
 4  
  * the terms of the GNU Lesser General Public License, version 2.1 or later
 5  
  * as published by the Free Software Foundation. This program is distributed
 6  
  * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 7  
  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 8  
  * See the GNU Lesser General Public License for more details.
 9  
  *
 10  
  * The License is available on the internet at:
 11  
  *      http://www.gnu.org/copyleft/lgpl.html
 12  
  * or by writing to:
 13  
  *      Free Software Foundation, Inc.
 14  
  *      59 Temple Place - Suite 330
 15  
  *      Boston, MA 02111-1307, USA
 16  
  *
 17  
  * © CrossWire Bible Society, 2005 - 2016
 18  
  *
 19  
  */
 20  
 package org.crosswire.jsword.passage;
 21  
 
 22  
 import java.io.IOException;
 23  
 import java.io.ObjectInputStream;
 24  
 import java.util.Iterator;
 25  
 
 26  
 import org.crosswire.jsword.versification.Versification;
 27  
 
 28  
 /**
 29  
  * A RocketPassage is a bit and heavy implementation of Passage that goes fairly
 30  
  * quickly once let of the leash. It manages its speed by creating contained
 31  
  * instances of DistinctPassage and RangedPassage and selects the fastest
 32  
  * implementation for each of its methods from the 3 available.
 33  
  * 
 34  
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
 35  
  * @author Joe Walker
 36  
  */
 37  
 public class RocketPassage extends BitwisePassage {
 38  
     /**
 39  
      * Create a new RocketPassage
 40  
      * 
 41  
      * @param v11n
 42  
      *            The Versification to which this Passage belongs.
 43  
      */
 44  
     public RocketPassage(Versification v11n) {
 45  0
         super(v11n);
 46  0
     }
 47  
 
 48  
     /**
 49  
      * Create a Verse from a human readable string. The opposite of getName(),
 50  
      * Given any RangedPassage v1, and the following
 51  
      * <code>RangedPassage v2 = new RangedPassage(v1.getName());</code> Then
 52  
      * <code>v1.equals(v2);</code> Theoretically, since there are many ways of
 53  
      * representing a RangedPassage as text string comparison along the lines
 54  
      * of: <code>v1.getName().equals(v2.getName())</code> could be false.
 55  
      * However since getName() is standardized this will be true. We don't need
 56  
      * to worry about thread safety in a ctor since we don't exist yet.
 57  
      * 
 58  
      * 
 59  
      * @param v11n
 60  
      *            The Versification to which this Passage belongs.
 61  
      * @param refs
 62  
      *            A String containing the text of the RangedPassage
 63  
      * @param basis
 64  
      *           The basis by which to interpret refs
 65  
      * @throws NoSuchVerseException
 66  
      *           if refs is invalid
 67  
      */
 68  
     protected RocketPassage(Versification v11n, String refs, Key basis) throws NoSuchVerseException {
 69  0
         super(v11n, refs, basis);
 70  0
     }
 71  
 
 72  
     /**
 73  
      * Create a Verse from a human readable string. The opposite of getName(),
 74  
      * Given any RangedPassage v1, and the following
 75  
      * <code>RangedPassage v2 = new RangedPassage(v1.getName());</code> Then
 76  
      * <code>v1.equals(v2);</code> Theoretically, since there are many ways of
 77  
      * representing a RangedPassage as text string comparison along the lines
 78  
      * of: <code>v1.getName().equals(v2.getName())</code> could be false.
 79  
      * However since getName() is standardized this will be true. We don't need
 80  
      * to worry about thread safety in a ctor since we don't exist yet.
 81  
      * 
 82  
      * 
 83  
      * @param v11n
 84  
      *            The Versification to which this Passage belongs.
 85  
      * @param refs
 86  
      *            A String containing the text of the RangedPassage
 87  
      * @throws NoSuchVerseException
 88  
      *            if refs is invalid
 89  
      */
 90  
     protected RocketPassage(Versification v11n, String refs) throws NoSuchVerseException {
 91  0
         this(v11n, refs, null);
 92  0
     }
 93  
 
 94  
     /*
 95  
      * (non-Javadoc)
 96  
      * 
 97  
      * @see org.crosswire.jsword.passage.AbstractPassage#optimizeReads()
 98  
      */
 99  
     @Override
 100  
     public void optimizeReads() {
 101  0
         raiseEventSuppresion();
 102  
 
 103  
         // We have to create the cached versions of these separately
 104  
         // so that the calculations made by addAll(this) can
 105  
         // safely call methods like countVerses() without any
 106  
         // danger of them being optimized before the optimizations
 107  
         // are ready for use.
 108  
 
 109  0
         DistinctPassage dtemp = new DistinctPassage(getVersification());
 110  0
         dtemp.raiseEventSuppresion();
 111  0
         dtemp.addAll(this);
 112  0
         dtemp.lowerEventSuppressionAndTest();
 113  
 
 114  0
         RangedPassage rtemp = new RangedPassage(getVersification());
 115  0
         rtemp.raiseEventSuppresion();
 116  0
         rtemp.addAll(this);
 117  0
         rtemp.lowerEventSuppressionAndTest();
 118  
 
 119  0
         distinct = dtemp;
 120  0
         ranged = rtemp;
 121  
 
 122  
         // This is just an optimization so we dont need to fire any events
 123  0
         lowerEventSuppressionAndTest();
 124  0
     }
 125  
 
 126  
     /*
 127  
      * (non-Javadoc)
 128  
      * 
 129  
      * @see org.crosswire.jsword.passage.AbstractPassage#optimizeWrites()
 130  
      */
 131  
     @Override
 132  
     protected void optimizeWrites() {
 133  0
         distinct = null;
 134  0
         ranged = null;
 135  0
     }
 136  
 
 137  
     /*
 138  
      * (non-Javadoc)
 139  
      * 
 140  
      * @see org.crosswire.jsword.passage.Passage#countRanges(int)
 141  
      */
 142  
     @Override
 143  
     public int countRanges(RestrictionType restrict) {
 144  0
         if (ranged != null) {
 145  0
             return ranged.countRanges(restrict);
 146  
         }
 147  
 
 148  0
         return super.countRanges(restrict);
 149  
     }
 150  
 
 151  
     /*
 152  
      * (non-Javadoc)
 153  
      * 
 154  
      * @see org.crosswire.jsword.passage.Passage#countVerses()
 155  
      */
 156  
     @Override
 157  
     public int countVerses() {
 158  0
         if (distinct != null) {
 159  0
             return distinct.countVerses();
 160  
         }
 161  
 
 162  0
         return super.countVerses();
 163  
     }
 164  
 
 165  
     /*
 166  
      * (non-Javadoc)
 167  
      * 
 168  
      * @see java.lang.Iterable#iterator()
 169  
      */
 170  
     @Override
 171  
     public Iterator<Key> iterator() {
 172  0
         if (distinct != null) {
 173  0
             return distinct.iterator();
 174  
         }
 175  
 
 176  0
         return super.iterator();
 177  
     }
 178  
 
 179  
     /*
 180  
      * (non-Javadoc)
 181  
      * 
 182  
      * @see org.crosswire.jsword.passage.Passage#rangeIterator(int)
 183  
      */
 184  
     @Override
 185  
     public Iterator<VerseRange> rangeIterator(RestrictionType restrict) {
 186  0
         if (ranged != null) {
 187  0
             return ranged.rangeIterator(restrict);
 188  
         }
 189  
 
 190  0
         return super.rangeIterator(restrict);
 191  
     }
 192  
 
 193  
     /*
 194  
      * (non-Javadoc)
 195  
      * 
 196  
      * @see org.crosswire.jsword.passage.Passage#isEmpty()
 197  
      */
 198  
     @Override
 199  
     public boolean isEmpty() {
 200  0
         if (distinct != null) {
 201  0
             return distinct.isEmpty();
 202  
         }
 203  
 
 204  0
         return super.isEmpty();
 205  
     }
 206  
 
 207  
     /*
 208  
      * (non-Javadoc)
 209  
      * 
 210  
      * @see org.crosswire.jsword.passage.Passage#getVerseAt(int)
 211  
      */
 212  
     @Override
 213  
     public Verse getVerseAt(int offset) throws ArrayIndexOutOfBoundsException {
 214  0
         if (distinct != null) {
 215  0
             return distinct.getVerseAt(offset);
 216  
         }
 217  
 
 218  0
         return super.getVerseAt(offset);
 219  
     }
 220  
 
 221  
     /*
 222  
      * (non-Javadoc)
 223  
      * 
 224  
      * @see org.crosswire.jsword.passage.Passage#getVerseRangeAt(int, int)
 225  
      */
 226  
     @Override
 227  
     public VerseRange getRangeAt(int offset, RestrictionType restrict) throws ArrayIndexOutOfBoundsException {
 228  0
         if (ranged != null) {
 229  0
             return ranged.getRangeAt(offset, restrict);
 230  
         }
 231  
 
 232  0
         return super.getRangeAt(offset, restrict);
 233  
     }
 234  
 
 235  
     /*
 236  
      * (non-Javadoc)
 237  
      * 
 238  
      * @see org.crosswire.jsword.passage.Passage#booksInPassage()
 239  
      */
 240  
     @Override
 241  
     public int booksInPassage() {
 242  0
         if (distinct != null) {
 243  0
             return distinct.booksInPassage();
 244  
         }
 245  
 
 246  0
         return super.booksInPassage();
 247  
     }
 248  
 
 249  
     /*
 250  
      * (non-Javadoc)
 251  
      * 
 252  
      * @see
 253  
      * org.crosswire.jsword.passage.Passage#containsAll(org.crosswire.jsword
 254  
      * .passage.Passage)
 255  
      */
 256  
     @Override
 257  
     public boolean containsAll(Passage that) {
 258  0
         if (ranged != null) {
 259  0
             return ranged.containsAll(that);
 260  
         }
 261  
 
 262  0
         return super.containsAll(that);
 263  
     }
 264  
 
 265  
     /**
 266  
      * Serialization support
 267  
      * 
 268  
      * @param is
 269  
      *            The stream to read our state from
 270  
      * @throws IOException
 271  
      *             if the read fails
 272  
      * @throws ClassNotFoundException
 273  
      *             If the read data is incorrect
 274  
      */
 275  
     private void readObject(ObjectInputStream is) throws IOException, ClassNotFoundException {
 276  0
         optimizeWrites();
 277  0
         is.defaultReadObject();
 278  0
     }
 279  
 
 280  
     /**
 281  
      * The contained DistinctPassage
 282  
      */
 283  
     private transient DistinctPassage distinct;
 284  
 
 285  
     /**
 286  
      * The contained RangedPassage
 287  
      */
 288  
     private transient RangedPassage ranged;
 289  
 
 290  
     /**
 291  
      * Serialization ID
 292  
      */
 293  
     private static final long serialVersionUID = 3258125864771401268L;
 294  
 }