Coverage Report

 /**
  * Distribution License:
  * JSword is free software; you can redistribute it and/or modify it under
  * the terms of the GNU Lesser General Public License, version 2.1 or later
  * as published by the Free Software Foundation. This program is distributed
  * in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
  * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * The License is available on the internet at:
  *      http://www.gnu.org/copyleft/lgpl.html
  * or by writing to:
  *      Free Software Foundation, Inc.
  *      59 Temple Place - Suite 330
  *      Boston, MA 02111-1307, USA
  *
  * © CrossWire Bible Society, 2005 - 2016
  *
  */
 package org.crosswire.jsword.passage;
 
 import org.crosswire.jsword.versification.Versification;
 
 /**
  * Types of Passage optimizations.
  * 
  * @see gnu.lgpl.License The GNU Lesser General Public License for details.
  * @author DM Smith
  */
 public enum PassageType {
     /**
      * Optimize the Passage for speed
      */
     SPEED {
         @Override
         public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
             if (passage == null || passage.length() == 0) {
                 return createEmptyPassage(v11n);
             }
             return new RocketPassage(v11n, passage, basis);
         }
 
         @Override
         public Passage createEmptyPassage(Versification v11n) {
             return new RocketPassage(v11n);
         }
     },
 
     /**
      * Optimize the Passage for write speed
      */
     WRITE_SPEED {
         @Override
         public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
             if (passage == null || passage.length() == 0) {
                 return createEmptyPassage(v11n);
             }
             return new BitwisePassage(v11n, passage, basis);
         }
 
         @Override
         public Passage createEmptyPassage(Versification v11n) {
             return new BitwisePassage(v11n);
         }
     },
 
     /**
      * Optimize the Passage for size
      */
     SIZE {
         @Override
         public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
             if (passage == null || passage.length() == 0) {
                 return createEmptyPassage(v11n);
             }
             return new DistinctPassage(v11n, passage, basis);
         }
 
         @Override
         public Passage createEmptyPassage(Versification v11n) {
             return new DistinctPassage(v11n);
         }
 
         /**
          * Serialization ID
          */
         private static final long serialVersionUID = -1959355535575121168L;
     },
 
     /**
      * Optimize the Passage for a mix
      */
     MIX {
         @Override
         public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
             if (passage == null || passage.length() == 0) {
                 return createEmptyPassage(v11n);
             }
             return new RangedPassage(v11n, passage, basis);
         }
 
         @Override
         public Passage createEmptyPassage(Versification v11n) {
             return new RangedPassage(v11n);
         }
     },
 
     /**
      * Optimize the Passage for tally operations
      */
     TALLY {
         @Override
         public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
             if (passage == null || passage.length() == 0) {
                 return createEmptyPassage(v11n);
             }
             return new PassageTally(v11n, passage, basis);
         }
 
         @Override
         public Passage createEmptyPassage(Versification v11n) {
             return new PassageTally(v11n);
         }
     };
 
     /**
      * Create an optimized passage
      * 
      * @param v11n
      *            the versification to which this reference pertains
      * @param passage
      * @param basis 
      * @return the optimized passage
      * @throws NoSuchVerseException
      */
     public abstract Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException;
     public Passage createPassage(Versification v11n, String passage) throws NoSuchVerseException {
         return createPassage(v11n, passage, null);
     }
 
     /**
      * Create an empty, optimized passage
      * 
      * @param v11n
      *            the versification to which this reference pertains
      * @return the optimized, empty passage
      */
     public abstract Passage createEmptyPassage(Versification v11n);
 
     /**
      * Lookup method to convert from a String
      * @param name 
      * @return the matching Passage type
      */
     public static PassageType fromString(String name) {
         for (PassageType v : values()) {
             if (v.name().equalsIgnoreCase(name)) {
                 return v;
             }
         }
 
         // cannot get here
         assert false;
         return null;
     }
 
     /**
      * Lookup method to convert from an integer
      * 
      * @param i 
      * @return the Passage type from its ordinal value
      */
     public static PassageType fromInteger(int i) {
         for (PassageType v : values()) {
             if (v.ordinal() == i) {
                 return v;
             }
         }
 
         // on error return SPEED
         return SPEED;
     }
 
     /**
      * Lookup method to convert from an integer
      * @param type 
      * @return the ordinal value for the passage type
      */
     public static int toInteger(PassageType type) {
         return type.ordinal();
     }
 }

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 org.crosswire.jsword.versification.Versification;
23
24		/**
25		* Types of Passage optimizations.
26		*
27		* @see gnu.lgpl.License The GNU Lesser General Public License for details.
28		* @author DM Smith
29		*/
30	0	public enum PassageType {
31		/**
32		* Optimize the Passage for speed
33		*/
34	0	SPEED {
35		@Override
36		public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
37	0	if (passage == null \|\| passage.length() == 0) {
38	0	return createEmptyPassage(v11n);
39		}
40	0	return new RocketPassage(v11n, passage, basis);
41		}
42
43		@Override
44		public Passage createEmptyPassage(Versification v11n) {
45	0	return new RocketPassage(v11n);
46		}
47		},
48
49		/**
50		* Optimize the Passage for write speed
51		*/
52	0	WRITE_SPEED {
53		@Override
54		public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
55	0	if (passage == null \|\| passage.length() == 0) {
56	0	return createEmptyPassage(v11n);
57		}
58	0	return new BitwisePassage(v11n, passage, basis);
59		}
60
61		@Override
62		public Passage createEmptyPassage(Versification v11n) {
63	0	return new BitwisePassage(v11n);
64		}
65		},
66
67		/**
68		* Optimize the Passage for size
69		*/
70	0	SIZE {
71		@Override
72		public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
73	0	if (passage == null \|\| passage.length() == 0) {
74	0	return createEmptyPassage(v11n);
75		}
76	0	return new DistinctPassage(v11n, passage, basis);
77		}
78
79		@Override
80		public Passage createEmptyPassage(Versification v11n) {
81	0	return new DistinctPassage(v11n);
82		}
83
84		/**
85		* Serialization ID
86		*/
87		private static final long serialVersionUID = -1959355535575121168L;
88		},
89
90		/**
91		* Optimize the Passage for a mix
92		*/
93	0	MIX {
94		@Override
95		public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
96	0	if (passage == null \|\| passage.length() == 0) {
97	0	return createEmptyPassage(v11n);
98		}
99	0	return new RangedPassage(v11n, passage, basis);
100		}
101
102		@Override
103		public Passage createEmptyPassage(Versification v11n) {
104	0	return new RangedPassage(v11n);
105		}
106		},
107
108		/**
109		* Optimize the Passage for tally operations
110		*/
111	0	TALLY {
112		@Override
113		public Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException {
114	0	if (passage == null \|\| passage.length() == 0) {
115	0	return createEmptyPassage(v11n);
116		}
117	0	return new PassageTally(v11n, passage, basis);
118		}
119
120		@Override
121		public Passage createEmptyPassage(Versification v11n) {
122	0	return new PassageTally(v11n);
123		}
124		};
125
126		/**
127		* Create an optimized passage
128		*
129		* @param v11n
130		* the versification to which this reference pertains
131		* @param passage
132		* @param basis
133		* @return the optimized passage
134		* @throws NoSuchVerseException
135		*/
136		public abstract Passage createPassage(Versification v11n, String passage, Key basis) throws NoSuchVerseException;
137		public Passage createPassage(Versification v11n, String passage) throws NoSuchVerseException {
138	0	return createPassage(v11n, passage, null);
139		}
140
141		/**
142		* Create an empty, optimized passage
143		*
144		* @param v11n
145		* the versification to which this reference pertains
146		* @return the optimized, empty passage
147		*/
148		public abstract Passage createEmptyPassage(Versification v11n);
149
150		/**
151		* Lookup method to convert from a String
152		* @param name
153		* @return the matching Passage type
154		*/
155		public static PassageType fromString(String name) {
156	0	for (PassageType v : values()) {
157	0	if (v.name().equalsIgnoreCase(name)) {
158	0	return v;
159		}
160		}
161
162		// cannot get here
163	0	assert false;
164	0	return null;
165		}
166
167		/**
168		* Lookup method to convert from an integer
169		*
170		* @param i
171		* @return the Passage type from its ordinal value
172		*/
173		public static PassageType fromInteger(int i) {
174	0	for (PassageType v : values()) {
175	0	if (v.ordinal() == i) {
176	0	return v;
177		}
178		}
179
180		// on error return SPEED
181	0	return SPEED;
182		}
183
184		/**
185		* Lookup method to convert from an integer
186		* @param type
187		* @return the ordinal value for the passage type
188		*/
189		public static int toInteger(PassageType type) {
190	0	return type.ordinal();
191		}
192		}