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 as published by
5    * the Free Software Foundation. This program is distributed in the hope
6    * that it will be useful, but WITHOUT ANY WARRANTY; without even the
7    * 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   * Copyright: 2005
18   *     The copyright to this program is held by it's authors.
19   *
20   * ID: $Id: GBFTagBuilders.java 2090 2011-03-07 04:13:05Z dmsmith $
21   */
22  package org.crosswire.jsword.book.filter.gbf;
23  
24  import java.util.HashMap;
25  import java.util.Map;
26  
27  import org.crosswire.common.util.Logger;
28  import org.crosswire.jsword.book.Book;
29  import org.crosswire.jsword.book.filter.gbf.GBFTags.BoldStartTag;
30  import org.crosswire.jsword.book.filter.gbf.GBFTags.CrossRefStartTag;
31  import org.crosswire.jsword.book.filter.gbf.GBFTags.DefaultEndTag;
32  import org.crosswire.jsword.book.filter.gbf.GBFTags.EOLTag;
33  import org.crosswire.jsword.book.filter.gbf.GBFTags.FootnoteEndTag;
34  import org.crosswire.jsword.book.filter.gbf.GBFTags.FootnoteStartTag;
35  import org.crosswire.jsword.book.filter.gbf.GBFTags.HeaderStartTag;
36  import org.crosswire.jsword.book.filter.gbf.GBFTags.IgnoredTag;
37  import org.crosswire.jsword.book.filter.gbf.GBFTags.ItalicStartTag;
38  import org.crosswire.jsword.book.filter.gbf.GBFTags.JustifyRightTag;
39  import org.crosswire.jsword.book.filter.gbf.GBFTags.OTQuoteStartTag;
40  import org.crosswire.jsword.book.filter.gbf.GBFTags.ParagraphTag;
41  import org.crosswire.jsword.book.filter.gbf.GBFTags.PoetryStartTag;
42  import org.crosswire.jsword.book.filter.gbf.GBFTags.PsalmStartTag;
43  import org.crosswire.jsword.book.filter.gbf.GBFTags.RedLetterStartTag;
44  import org.crosswire.jsword.book.filter.gbf.GBFTags.StrongsMorphTag;
45  import org.crosswire.jsword.book.filter.gbf.GBFTags.StrongsWordTag;
46  import org.crosswire.jsword.book.filter.gbf.GBFTags.TextFootnoteTag;
47  import org.crosswire.jsword.book.filter.gbf.GBFTags.TextTag;
48  import org.crosswire.jsword.book.filter.gbf.GBFTags.TitleStartTag;
49  import org.crosswire.jsword.book.filter.gbf.GBFTags.UnderlineStartTag;
50  import org.crosswire.jsword.passage.Key;
51  
52  /**
53   * This class is a convenience to get GBF Tags.
54   * 
55   * The best place to go for more information about the GBF spec that I have
56   * found is: <a
57   * href="http://ebible.org/bible/gbf.htm">http://ebible.org/bible/gbf.htm</a>
58   * 
59   * @see gnu.lgpl.License for license details.<br>
60   *      The copyright to this program is held by it's authors.
61   * @author Joe Walker [joe at eireneh dot com]
62   * @author DM Smith [dmsmith555 at yahoo dot com]
63   */
64  public final class GBFTagBuilders {
65      /**
66       *
67       */
68      private GBFTagBuilders() {
69      }
70  
71      /**
72       * @param name
73       * @return return a GBF Tag for the given tag name
74       */
75      public static Tag getTag(Book book, Key key, String name) {
76          Tag tag = null;
77          int length = name.length();
78          if (length > 0) {
79              // Only the first two letters of the tag are indicative of the tag
80              // The rest, if present, is data.
81              TagBuilder builder = null;
82              if (length == 2) {
83                  builder = BUILDERS.get(name);
84              } else {
85                  builder = BUILDERS.get(name.substring(0, 2));
86              }
87  
88              if (builder != null) {
89                  tag = builder.createTag(name);
90              }
91  
92              if (tag == null) {
93                  // I'm not confident enough that we handle all the GBF tags
94                  // that I will blame the book instead of the program
95                  log.warn("In " + book.getInitials() + "(" + key.getName() + ") ignoring tag of <" + name + ">");
96                  // DataPolice.report("Ignoring tag of <" + name + ">");
97              }
98          }
99          return tag;
100     }
101 
102     /**
103      * @param text
104      * @return get a Text Tag object containing the text
105      */
106     public static Tag getTextTag(String text) {
107         return new TextTag(text);
108     }
109 
110     /**
111      *
112      */
113     static final class BoldStartTagBuilder implements TagBuilder {
114         public Tag createTag(String name) {
115             return new BoldStartTag(name);
116         }
117     }
118 
119     /**
120      *
121      */
122     static final class CrossRefStartTagBuilder implements TagBuilder {
123         public Tag createTag(final String name) {
124             return new CrossRefStartTag(name);
125         }
126     }
127 
128     /**
129      *
130      */
131     static final class DefaultEndTagBuilder implements TagBuilder {
132         public Tag createTag(String name) {
133             return new DefaultEndTag(name);
134         }
135     }
136 
137     /**
138      *
139      */
140     static final class EndOfLineTagBuilder implements TagBuilder {
141         public Tag createTag(final String name) {
142             return new EOLTag(name);
143         }
144 
145     }
146 
147     /**
148     *
149     */
150     static final class EscapeTagBuilder implements TagBuilder {
151         public Tag createTag(final String name) {
152             if ("CG".equals(name)) {
153                 return new TextTag("&gt;");
154             }
155 
156             // else "CT"
157             return new TextTag("&lt;");
158         }
159 
160     }
161 
162     /**
163      *
164      */
165     static final class FootnoteStartTagBuilder implements TagBuilder {
166         public Tag createTag(String name) {
167             return new FootnoteStartTag(name);
168         }
169     }
170 
171     /**
172      *
173      */
174     static final class FootnoteEndTagBuilder implements TagBuilder {
175         public Tag createTag(String name) {
176             return new FootnoteEndTag(name);
177         }
178     }
179 
180     /**
181      *
182      */
183     static final class HeaderStartTagBuilder implements TagBuilder {
184         public Tag createTag(String name) {
185             return new HeaderStartTag(name);
186         }
187     }
188 
189     /**
190      *
191      */
192     static final class IgnoredTagBuilder implements TagBuilder {
193         public Tag createTag(final String name) {
194             return new IgnoredTag(name);
195         }
196     }
197 
198     /**
199      *
200      */
201     static final class ItalicStartTagBuilder implements TagBuilder {
202        public Tag createTag(String name) {
203             return new ItalicStartTag(name);
204         }
205     }
206 
207     /**
208      *
209      */
210     static final class JustifyRightTagBuilder implements TagBuilder {
211         public Tag createTag(String name) {
212             return new JustifyRightTag(name);
213         }
214     }
215 
216     /**
217      *
218      */
219     static final class OTQuoteStartTagBuilder implements TagBuilder {
220        public Tag createTag(String name) {
221             return new OTQuoteStartTag(name);
222         }
223     }
224 
225     /**
226      *
227      */
228     static final class ParagraphTagBuilder implements TagBuilder {
229        public Tag createTag(String name) {
230             return new ParagraphTag(name);
231         }
232     }
233 
234     /**
235      *
236      */
237     static final class PoetryStartTagBuilder implements TagBuilder {
238        public Tag createTag(String name) {
239             return new PoetryStartTag(name);
240         }
241 
242     }
243 
244     /**
245      *
246      */
247     static final class PsalmTitleStartTagBuilder implements TagBuilder {
248         public Tag createTag(String name) {
249             return new PsalmStartTag(name);
250         }
251 
252     }
253 
254     /**
255      *
256      */
257     static final class RedLetterStartTagBuilder implements TagBuilder {
258        public Tag createTag(String name) {
259             return new RedLetterStartTag(name);
260         }
261     }
262 
263     /**
264      *
265      */
266     static final class StrongsMorphTagBuilder implements TagBuilder {
267        public Tag createTag(final String name) {
268             return new StrongsMorphTag(name);
269         }
270     }
271 
272     /**
273      *
274      */
275     static final class StrongsWordTagBuilder implements TagBuilder {
276         public Tag createTag(final String name) {
277             return new StrongsWordTag(name);
278         }
279     }
280 
281     /**
282      *
283      */
284     static final class TextFootnoteTagBuilder implements TagBuilder {
285         public Tag createTag(String name) {
286             return new TextFootnoteTag(name);
287         }
288     }
289 
290     /**
291      *
292      */
293     static final class TitleStartTagBuilder implements TagBuilder {
294         public Tag createTag(String name) {
295             return new TitleStartTag(name);
296         }
297     }
298 
299     /**
300      *
301      */
302     static final class UnderlineStartTagBuilder implements TagBuilder {
303         public Tag createTag(String name) {
304             return new UnderlineStartTag(name);
305         }
306     }
307 
308     /**
309      * The log stream
310      */
311     private static final Logger log = Logger.getLogger(GBFTagBuilders.class);
312 
313     /**
314      * The <code>BUILDERS</code> maps the 2 letter GBF tag to a class that
315      * proxies for the tag.
316      */
317     private static final Map<String, TagBuilder> BUILDERS = new HashMap<String, TagBuilder>();
318     static {
319         TagBuilder defaultEndTagBuilder = new DefaultEndTagBuilder();
320         TagBuilder ignoreTagBuilder = new IgnoredTagBuilder();
321 
322         BUILDERS.put("FB", new BoldStartTagBuilder());
323         BUILDERS.put("Fb", defaultEndTagBuilder);
324 
325         BUILDERS.put("FI", new ItalicStartTagBuilder());
326         BUILDERS.put("Fi", defaultEndTagBuilder);
327 
328         BUILDERS.put("FR", new RedLetterStartTagBuilder());
329         BUILDERS.put("Fr", defaultEndTagBuilder);
330 
331         BUILDERS.put("FU", new UnderlineStartTagBuilder());
332         BUILDERS.put("Fu", defaultEndTagBuilder);
333 
334         BUILDERS.put("RX", new CrossRefStartTagBuilder());
335         BUILDERS.put("Rx", defaultEndTagBuilder);
336 
337         BUILDERS.put("CL", new EndOfLineTagBuilder());
338         BUILDERS.put("CM", new ParagraphTagBuilder());
339 
340         BUILDERS.put("RF", new FootnoteStartTagBuilder());
341         BUILDERS.put("Rf", new FootnoteEndTagBuilder());
342         BUILDERS.put("RB", new TextFootnoteTagBuilder());
343 
344         BUILDERS.put("TS", new HeaderStartTagBuilder());
345         BUILDERS.put("Ts", defaultEndTagBuilder);
346 
347         BUILDERS.put("TB", new PsalmTitleStartTagBuilder());
348         BUILDERS.put("Tb", defaultEndTagBuilder);
349 
350         BUILDERS.put("TH", new TitleStartTagBuilder());
351         BUILDERS.put("Th", defaultEndTagBuilder);
352 
353         BUILDERS.put("BA", ignoreTagBuilder);
354         BUILDERS.put("BC", ignoreTagBuilder);
355         BUILDERS.put("BI", ignoreTagBuilder);
356         BUILDERS.put("BN", ignoreTagBuilder);
357         BUILDERS.put("BO", ignoreTagBuilder);
358         BUILDERS.put("BP", ignoreTagBuilder);
359 
360         BUILDERS.put("JR", new JustifyRightTagBuilder());
361         BUILDERS.put("JL", ignoreTagBuilder);
362 
363         BUILDERS.put("FO", new OTQuoteStartTagBuilder());
364         BUILDERS.put("Fo", defaultEndTagBuilder);
365 
366         BUILDERS.put("PP", new PoetryStartTagBuilder());
367         BUILDERS.put("Pp", defaultEndTagBuilder);
368 
369         TagBuilder builder = new StrongsWordTagBuilder();
370         BUILDERS.put("WH", builder);
371         BUILDERS.put("WG", builder);
372         BUILDERS.put("WT", new StrongsMorphTagBuilder());
373 
374         BUILDERS.put("CG", new EscapeTagBuilder());
375         BUILDERS.put("CT", new EscapeTagBuilder());
376     }
377 }
378