EmailDocumentFormat.java
001 /*
002  *  EmailDocumentFormat.java
003  *
004  *  Copyright (c) 1995-2012, The University of Sheffield. See the file
005  *  COPYRIGHT.txt in the software or at http://gate.ac.uk/gate/COPYRIGHT.txt
006  *
007  *  This file is part of GATE (see http://gate.ac.uk/), and is free
008  *  software, licenced under the GNU Library General Public License,
009  *  Version 2, June 1991 (in the distribution as file licence.html,
010  *  and also available at http://gate.ac.uk/gate/licence.html).
011  *
012  *  Cristian URSU, 3/Aug/2000
013  *
014  *  $Id: EmailDocumentFormat.java 17638 2014-03-12 09:36:47Z markagreenwood $
015  */
016 
017 package gate.corpora;
018 
019 import gate.Annotation;
020 import gate.AnnotationSet;
021 import gate.GateConstants;
022 import gate.Resource;
023 import gate.creole.ResourceInstantiationException;
024 import gate.creole.metadata.AutoInstance;
025 import gate.creole.metadata.CreoleResource;
026 import gate.email.EmailDocumentHandler;
027 import gate.event.StatusListener;
028 import gate.util.DocumentFormatException;
029 import gate.util.InvalidOffsetException;
030 
031 import java.io.IOException;
032 import java.util.Iterator;
033 
034 /** The format of Documents. Subclasses of DocumentFormat know about
035   * particular MIME types and how to unpack the information in any
036   * markup or formatting they contain into GATE annotations. Each MIME
037   * type has its own subclass of DocumentFormat, e.g. XmlDocumentFormat,
038   * RtfDocumentFormat, MpegDocumentFormat. These classes register themselves
039   * with a static index residing here when they are constructed. Static
040   * getDocumentFormat methods can then be used to get the appropriate
041   * format class for a particular document.
042   */
043 @CreoleResource(name = "GATE EMAIL Document Format", isPrivate = true,
044     autoinstances = {@AutoInstance(hidden = true)})
045 public class EmailDocumentFormat extends TextualDocumentFormat
046 {
047   private static final long serialVersionUID = 5738598679165395119L;
048 
049   /** Default construction */
050   public EmailDocumentFormat() { super();}
051 
052   /** Unpack the markup in the document. This converts markup from the
053     * native format (e.g. EMAIL) into annotations in GATE format.
054     * Uses the markupElementsMap to determine which elements to convert, and
055     * what annotation type names to use.
056     * It always tryes to parse te doc's content. It doesn't matter if the
057     * sourceUrl is null or not.
058     *
059     @param doc The gate document you want to parse.
060     *
061     */
062 
063   @Override
064   public void unpackMarkup(gate.Document docthrows DocumentFormatException{
065     if ( (doc == null||
066          (doc.getSourceUrl() == null && doc.getContent() == null)){
067 
068       throw new DocumentFormatException(
069                "GATE document is null or no content found. Nothing to parse!");
070     }// End if
071 
072     setNewLineProperty(doc);
073 
074     // create an EmailDocumentHandler
075     EmailDocumentHandler emailDocHandler = null;
076     emailDocHandler = new  gate.email.EmailDocumentHandler(
077                                                        doc,
078                                                        this.markupElementsMap,
079                                                        this.element2StringMap);
080     StatusListener statusListener = new StatusListener(){
081         @Override
082         public void statusChanged(String text) {
083           // this is implemented in DocumentFormat.java and inherited here
084           fireStatusChanged(text);
085         }//statusChanged(String text)
086     };
087     // Register a status listener with it
088     emailDocHandler.addStatusListener(statusListener);
089     try{
090       // Call the method that creates annotations on the gate document
091       emailDocHandler.annotateMessages();
092       // Process the body annotations and search for paragraphs
093       AnnotationSet bodyAnnotations = doc.getAnnotations(
094                     GateConstants.ORIGINAL_MARKUPS_ANNOT_SET_NAME).get("body");
095       if (bodyAnnotations != null && !bodyAnnotations.isEmpty()){
096         Iterator<Annotation> iter = bodyAnnotations.iterator();
097         while(iter.hasNext()){
098           Annotation a = iter.next();
099           annotateParagraphs(doc,a.getStartNode().getOffset().intValue(),
100                                  a.getEndNode().getOffset().intValue(),
101                                  GateConstants.ORIGINAL_MARKUPS_ANNOT_SET_NAME);
102         }// End while
103       }// End if
104     catch (IOException e){
105       throw new DocumentFormatException("Couldn't create a buffered reader ",e);
106     catch (InvalidOffsetException e){
107       throw new DocumentFormatException(e);
108     }finally{
109       emailDocHandler.removeStatusListener(statusListener);
110     }// End try
111   }//unpackMarkup(doc)
112 
113   /** Initialise this resource, and return it. */
114   @Override
115   public Resource init() throws ResourceInstantiationException{
116     // Register EMAIL mime type
117     MimeType mime = new MimeType("text","email");
118     // Register the class handler for this mime type
119     mimeString2ClassHandlerMap.put(mime.getType()"/" + mime.getSubtype(),
120                                                                           this);
121     // Register the mime type with mine string
122     mimeString2mimeTypeMap.put(mime.getType() "/" + mime.getSubtype(), mime);
123     // Register file sufixes for this mime type
124     suffixes2mimeTypeMap.put("eml",mime);
125     suffixes2mimeTypeMap.put("email",mime);
126     suffixes2mimeTypeMap.put("mail",mime);
127     // Register magic numbers for this mime type
128     magic2mimeTypeMap.put("Subject:",mime);
129     // Set the mimeType for this language resource
130     setMimeType(mime);
131     return this;
132   }// init()
133 }// class EmailDocumentFormat