Java > Open Source Codes > org > columba > mail > folder > AbstractMessageFolder


1 // The contents of this file are subject to the Mozilla Public License Version
2 // 1.1
3 //(the "License"); you may not use this file except in compliance with the
4 //License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
5 //
6 //Software distributed under the License is distributed on an "AS IS" basis,
7 //WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
8 //for the specific language governing rights and
9 //limitations under the License.
10 //
11 //The Original Code is "The Columba Project"
12 //
13 //The Initial Developers of the Original Code are Frederik Dietz and Timo
14 // Stich.
15 //Portions created by Frederik Dietz and Timo Stich are Copyright (C) 2003.
16 //
17 //All Rights Reserved.
18
19 package org.columba.mail.folder;
20
21 import java.io.File ;
22 import java.io.InputStream ;
23 import java.nio.charset.Charset ;
24 import java.nio.charset.UnsupportedCharsetException ;
25 import java.util.logging.Logger ;
26
27 import org.columba.api.command.IStatusObservable;
28 import org.columba.core.command.StatusObservableImpl;
29 import org.columba.core.filter.FilterList;
30 import org.columba.core.filter.IFilter;
31 import org.columba.core.filter.IFilterList;
32 import org.columba.core.io.DiskIO;
33 import org.columba.core.xml.XmlElement;
34 import org.columba.mail.config.FolderItem;
35 import org.columba.mail.config.IFolderItem;
36 import org.columba.mail.folder.command.MarkMessageCommand;
37 import org.columba.mail.folder.event.FolderEvent;
38 import org.columba.mail.folder.event.IFolderListener;
39 import org.columba.mail.folder.search.DefaultSearchEngine;
40 import org.columba.mail.message.ICloseableIterator;
41 import org.columba.mail.message.IColumbaHeader;
42 import org.columba.mail.message.IHeaderList;
43 import org.columba.ristretto.coder.Base64DecoderInputStream;
44 import org.columba.ristretto.coder.CharsetDecoderInputStream;
45 import org.columba.ristretto.coder.QuotedPrintableDecoderInputStream;
46 import org.columba.ristretto.message.Attributes;
47 import org.columba.ristretto.message.Flags;
48 import org.columba.ristretto.message.MailboxInfo;
49 import org.columba.ristretto.message.MimeHeader;
50
51 /**
52  * Abstract Basic AbstractMessageFolder class. It is subclassed by every folder
53  * class containing messages and therefore offering methods to alter the
54  * mailbox.
55  * <p>
56  * Folders are plugins and therefore dynamically created. This should make it
57  * easy to write new folders in the future.
58  * <p>
59  * To make it very easy to add new local mailbox formats, we added a slightly
60  * more complex class hierachy in org.columba.mail.folder,
61  * org.columba.mail.folder.headercache. An implementation example can be found
62  * in org.columba.mail.folder.mh.
63  * <p>
64  * Please note, that you only need to implement {@link DataStorageInstance}
65  * which should be trivial in most cases. Then create a class extending
66  * {@link AbstractLocalFolder}and plug your datastorage in this folder in
67  * overwriting getDataStorageInstance() method.
68  * <p>
69  * Last, don't forget to register your folder plugin:
70  * <p>
71  * Add your folder to <code>org.columba.mail.plugin.folder.xml</code>. This
72  * way you create an association of the folder name and the class which gets
73  * loaded.
74  * <p>
75  * Edit your tree.xml file and replace the MH mailbox implementation with yours.
76  *
77  * @author freddy
78  * @created 19. Juni 2001
79  */
80 public abstract class AbstractMessageFolder extends AbstractFolder implements
81         IMailbox {
82
83     /** JDK 1.4+ logging framework logger, used for logging. */
84     private static final Logger LOG = Logger
85             .getLogger("org.columba.mail.folder");
86
87     /**
88      * total/unread/recent count of messages in this folder
89      */
90     protected IMailboxInfo messageFolderInfo = new ColumbaMailboxInfo();
91
92     /**
93      * list of filters
94      */
95     protected FilterList filterList;
96
97     /**
98      *
99      * set changed to true if the folder data changes.
100      */
101     protected boolean changed = false;
102
103     /**
104      * directory where this folders files are stored
105      */
106     protected File directoryFile;
107
108     /**
109      * The last selected uid for the current folder. This information is used to
110      * show the last selected message, if you switch to the current folder and
111      * the lastSelection field is set. If the lastSelection field is null, the
112      * first message in the table for this folder is shown. Have a look to
113      * org.columba.mail.gui.table.TableController#showHeaderList
114      */
115     protected Object lastSelection;
116
117     /**
118      * Status information updates are handled in using IStatusObservable.
119      * <p>
120      * Every command has to register its interest to this events before
121      * accessing the folder.
122      */
123     protected IStatusObservable observable = new StatusObservableImpl();
124
125     // implement your own search-engine here
126 protected DefaultSearchEngine searchEngine;
127
128     /**
129      * Standard constructor.
130      *
131      * @param item
132      * <class>FolderItem </class> contains information about the
133      * folder
134      */
135     public AbstractMessageFolder(FolderItem item, String path) {
136         super(item);
137
138         String dir = path + System.getProperty("file.separator") + getId();
139
140         if (DiskIO.ensureDirectory(dir)) {
141             directoryFile = new File (dir);
142         }
143
144         loadMessageFolderInfo();
145     }
146
147     // used by virtual folder only
148 public AbstractMessageFolder(FolderItem item) {
149         super(item);
150
151         loadMessageFolderInfo();
152     }
153
154     protected AbstractMessageFolder() {
155         super();
156     }
157
158     /**
159      * @param type
160      */
161     public AbstractMessageFolder(String name, String type, String path) {
162         super(name, type);
163
164         String dir = path + System.getProperty("file.separator") + getId();
165
166         if (DiskIO.ensureDirectory(dir)) {
167             directoryFile = new File (dir);
168         }
169
170         loadMessageFolderInfo();
171     }
172
173     // only used by VirtualFolder
174 public AbstractMessageFolder(String name, String type) {
175         super(name, type);
176
177         loadMessageFolderInfo();
178     }
179
180     protected void recreateMessageFolderInfo() {
181         messageFolderInfo.reset();
182
183         try {
184             ICloseableIterator it = getHeaderList().headerIterator();
185
186             while (it.hasNext()) {
187                 Flags flags = ((IColumbaHeader) it.next()).getFlags();
188                 messageFolderInfo.incExists();
189                 if (flags.getRecent()) {
190                     messageFolderInfo.incRecent();
191                 }
192                 if (!flags.getSeen()) {
193                     messageFolderInfo.incUnseen();
194                 }
195             }
196
197         } catch (Exception e) {
198             LOG.severe(e.getLocalizedMessage());
199         }
200
201     }
202
203     /**
204      * Propagates an event to all registered listeners notifying them of a
205      * message addition.
206      *
207      * @param flags
208      */
209     public void fireMessageAdded(Object uid, Flags flags) {
210         try {
211             getMessageFolderInfo().incExists();
212
213             if (flags.getRecent()) {
214                 getMessageFolderInfo().incRecent();
215             }
216             if (!flags.getSeen()) {
217                 getMessageFolderInfo().incUnseen();
218             }
219         } catch (MailboxInfoInvalidException e) {
220             recreateMessageFolderInfo();
221         }
222         setChanged(true);
223
224         // update treenode
225 fireFolderPropertyChanged();
226
227         FolderEvent e = new FolderEvent(this, uid);
228         // Guaranteed to return a non-null array
229 Object [] listeners = listenerList.getListenerList();
230
231         // Process the listeners last to first, notifying
232 // those that are interested in this event
233 for (int i = listeners.length - 2; i >= 0; i -= 2) {
234             if (listeners[i] == IFolderListener.class) {
235                 ((IFolderListener) listeners[i + 1]).messageAdded(e);
236             }
237         }
238     }
239
240     /**
241      * Propagates an event to all registered listeners notifying them of a
242      * message removal.
243      */
244     public void fireMessageRemoved(Object uid, Flags flags) {
245
246         try {
247             if (flags != null) {
248                 if (flags.getRecent()) {
249                     getMessageFolderInfo().decRecent();
250                 }
251                 if (!flags.getSeen()) {
252                     getMessageFolderInfo().decUnseen();
253                 }
254             }
255             getMessageFolderInfo().decExists();
256         } catch (MailboxInfoInvalidException e) {
257             recreateMessageFolderInfo();
258         }
259
260         setChanged(true);
261
262         // update treenode
263 fireFolderPropertyChanged();
264
265         FolderEvent e = new FolderEvent(this, uid);
266         // Guaranteed to return a non-null array
267 Object [] listeners = listenerList.getListenerList();
268
269         // Process the listeners last to first, notifying
270 // those that are interested in this event
271 for (int i = listeners.length - 2; i >= 0; i -= 2) {
272             if (listeners[i] == IFolderListener.class) {
273                 ((IFolderListener) listeners[i + 1]).messageRemoved(e);
274             }
275         }
276     }
277
278     /**
279      * Propagates an event to all registered listeners notifying them of a
280      * message removal.
281      */
282     public void fireMessageFlagChanged(Object uid, Flags oldFlags, int variant) {
283
284         // @author fdietz
285 // -> Moved code for updating mailfolderinfo to markMessage()
286 // intentionally!
287 //
288 setChanged(true);
289
290         FolderEvent e = new FolderEvent(this, uid, oldFlags, variant);
291
292         // Guaranteed to return a non-null array
293 Object [] listeners = listenerList.getListenerList();
294
295         // Process the listeners last to first, notifying
296 // those that are interested in this event
297 for (int i = listeners.length - 2; i >= 0; i -= 2) {
298             if (listeners[i] == IFolderListener.class) {
299                 ((IFolderListener) listeners[i + 1]).messageFlagChanged(e);
300             }
301         }
302     }
303
304     /**
305      * Returns the directory where the messages are saved
306      *
307      * @return File the file representing the mailbox directory
308      */
309     public File getDirectoryFile() {
310         return directoryFile;
311     }
312
313     /**
314      * Call this method if folder data changed, so that we know if we have to
315      * save the header cache.
316      *
317      * @param b
318      */
319     public void setChanged(boolean b) {
320         changed = b;
321     }
322
323     /**
324      * Change the <class>MessageFolderInfo </class>
325      *
326      * @param i
327      * the new messagefolderinfo
328      */
329     public void setMessageFolderInfo(MailboxInfo i) {
330         messageFolderInfo = new ColumbaMailboxInfo(i);
331     }
332
333     /**
334      * Check if folder was modified.
335      *
336      * @return boolean True, if folder data changed. False, otherwise.
337      */
338     protected boolean hasChanged() {
339         return changed;
340     }
341
342     /**
343      * Method getMessageFolderInfo.
344      *
345      * @return MessageFolderInfo
346      */
347     public IMailboxInfo getMessageFolderInfo() {
348         return messageFolderInfo;
349     }
350
351     /**
352      * Method getFilterList.
353      *
354      * @return FilterList
355      */
356     public IFilterList getFilterList() {
357         return filterList;
358     }
359
360     /** ********************************** treenode implementation ********** */
361     /**
362      * @see java.lang.Object#toString()
363      */
364     public String toString() {
365         return getName();
366     }
367
368     /**
369      * save messagefolderinfo to xml-configuration
370      *
371      */
372     protected void saveMessageFolderInfo() {
373         IMailboxInfo info = getMessageFolderInfo();
374
375         IFolderItem item = getConfiguration();
376
377         XmlElement property = item.getElement("property");
378
379         property.addAttribute("exists", new Integer (info.getExists())
380                 .toString());
381         property.addAttribute("unseen", new Integer (info.getUnseen())
382                 .toString());
383         // on startup, there's shouldn't be any recent messages
384 // -> we simply remember 0 recent messages here
385 // property.addAttribute("recent", "0");
386
387         property.addAttribute("recent", new Integer (info.getRecent())
388                 .toString());
389
390         if (info.getUidNext() != -1) {
391             property.addAttribute("uidnext", new Integer (info.getUidNext())
392                     .toString());
393             property.addAttribute("uidvalidity", new Integer (info
394                     .getUidValidity()).toString());
395         }
396
397     }
398
399     /**
400      *
401      * get messagefolderinfo from xml-configuration
402      *
403      */
404     protected void loadMessageFolderInfo() {
405         XmlElement property = getConfiguration().getElement("property");
406
407         if (property == null) {
408             return;
409         }
410
411         IMailboxInfo info = getMessageFolderInfo();
412
413         String exists = property.getAttribute("exists");
414
415         if (exists != null) {
416             info.setExists(Integer.parseInt(exists));
417         }
418
419         String recent = property.getAttribute("recent");
420
421         if (recent != null) {
422             info.setRecent(Integer.parseInt(recent));
423         }
424
425         String unseen = property.getAttribute("unseen");
426
427         if (unseen != null) {
428             info.setUnseen(Integer.parseInt(unseen));
429         }
430
431         String uidnext = property.getAttribute("uidnext");
432
433         if (uidnext != null) {
434             info.setUidNext(Integer.parseInt(uidnext));
435         }
436
437         String uidvalidity = property.getAttribute("uidvalidty");
438
439         if (uidvalidity != null) {
440             info.setUidValidity(Integer.parseInt(uidvalidity));
441         }
442
443         // Check if the MessageFolderInfo is sane
444 if (!info.isSane()) {
445             recreateMessageFolderInfo();
446         }
447
448     }
449
450     /**
451      *
452      * use this method to save folder meta-data when closing Columba
453      *
454      */
455     public void save() throws Exception {
456         saveMessageFolderInfo();
457         if (getSearchEngine() != null) {
458             getSearchEngine().save();
459         }
460     }
461
462     /**
463      * Returns the last selected Message for the current folder. If no message
464      * was selected, it returns null. The return-value is the uid of the last
465      * selected message.
466      */
467     public Object getLastSelection() {
468         return lastSelection;
469     }
470
471     /**
472      * Sets the last selection for the current folder. This should be the uid of
473      * the last selected Message for the current folder.
474      */
475     public void setLastSelection(Object lastSel) {
476         lastSelection = lastSel;
477     }
478
479     /**
480      * @return observable containing status information
481      */
482     public IStatusObservable getObservable() {
483         return observable;
484     }
485
486     /**
487      * @see org.columba.mail.folder.FolderTreeNode#supportsAddMessage()
488      */
489     public boolean supportsAddMessage() {
490         return true;
491     }
492
493     /**
494      * Returns true if this folder is an Inbox folder.
495      *
496      * @return true if this folder is an Inbox folder.
497      */
498     public boolean isInboxFolder() {
499         return false;
500     }
501
502     /**
503      * Returns true if this folder is the Trash folder.
504      *
505      * @return true if this folder is the Trash folder.
506      */
507     public boolean isTrashFolder() {
508         return false;
509     }
510
511     protected void updateMailFolderInfo(Flags flags, int variant)
512             throws Exception {
513         boolean updated = false;
514
515         if (flags == null) {
516             return;
517         }
518
519         try {
520             switch (variant) {
521             case MarkMessageCommand.MARK_AS_READ: {
522                 if (flags.getRecent()) {
523                     getMessageFolderInfo().decRecent();
524                     updated = true;
525                 }
526
527                 if (!flags.getSeen()) {
528                     getMessageFolderInfo().decUnseen();
529                     updated = true;
530                 }
531
532                 break;
533             }
534
535             case MarkMessageCommand.MARK_AS_UNREAD: {
536                 if (flags.getSeen()) {
537                     getMessageFolderInfo().incUnseen();
538                     updated = true;
539                 }
540
541                 break;
542             }
543
544             case MarkMessageCommand.MARK_AS_EXPUNGED: {
545                 if (!flags.getSeen()) {
546                     getMessageFolderInfo().decUnseen();
547                     updated = true;
548                 }
549
550                 if (flags.getRecent()) {
551                     getMessageFolderInfo().decRecent();
552                     updated = true;
553                 }
554
555                 break;
556             }
557
558             case MarkMessageCommand.MARK_AS_RECENT: {
559                 if (!flags.getRecent()) {
560                     getMessageFolderInfo().incRecent();
561                     updated = true;
562                 }
563
564                 break;
565             }
566             case MarkMessageCommand.MARK_AS_NOTRECENT: {
567                 if (flags.getRecent()) {
568                     getMessageFolderInfo().decRecent();
569                     updated = true;
570                 }
571
572                 break;
573             }
574
575             }
576         } catch (MailboxInfoInvalidException e) {
577             recreateMessageFolderInfo();
578         }
579
580         // update treenode
581 if (updated)
582             fireFolderPropertyChanged();
583     }
584
585     /**
586      * @param uid
587      * @param variant
588      * @param worker
589      * @throws Exception
590      */
591     protected void markMessage(Object uid, int variant) throws Exception {
592         IColumbaHeader header = getHeaderList().get(uid);
593
594         Flags flags = header.getFlags();
595
596         updateMailFolderInfo(flags, variant);
597
598         if (flags == null) {
599             return;
600         }
601         Flags oldFlags = (Flags) flags.clone();
602
603         switch (variant) {
604         case MarkMessageCommand.MARK_AS_READ: {
605
606             flags.setSeen(true);
607             flags.setRecent(false);
608
609             break;
610         }
611
612         case MarkMessageCommand.MARK_AS_UNREAD: {
613
614             flags.setSeen(false);
615
616             break;
617         }
618
619         case MarkMessageCommand.MARK_AS_FLAGGED: {
620             flags.setFlagged(true);
621
622             break;
623         }
624
625         case MarkMessageCommand.MARK_AS_UNFLAGGED: {
626             flags.setFlagged(false);
627
628             break;
629         }
630
631         case MarkMessageCommand.MARK_AS_EXPUNGED: {
632
633             flags.setSeen(true);
634             flags.setRecent(false);
635             flags.setDeleted(true);
636
637             break;
638         }
639
640         case MarkMessageCommand.MARK_AS_UNEXPUNGED: {
641             flags.setDeleted(false);
642
643             break;
644         }
645
646         case MarkMessageCommand.MARK_AS_ANSWERED: {
647             flags.setAnswered(true);
648
649             break;
650         }
651         case MarkMessageCommand.MARK_AS_UNANSWERED: {
652             flags.setAnswered(false);
653
654             break;
655         }
656
657         case MarkMessageCommand.MARK_AS_SPAM: {
658             header.getAttributes().put("columba.spam", Boolean.TRUE);
659
660             break;
661         }
662
663         case MarkMessageCommand.MARK_AS_NOTSPAM: {
664             header.getAttributes().put("columba.spam", Boolean.FALSE);
665
666             break;
667         }
668         case MarkMessageCommand.MARK_AS_DRAFT: {
669             flags.setDraft(true);
670
671             break;
672         }
673         case MarkMessageCommand.MARK_AS_NOTDRAFT: {
674             flags.setDraft(false);
675
676             break;
677         }
678         case MarkMessageCommand.MARK_AS_RECENT: {
679             flags.setRecent(true);
680
681             break;
682         }
683         case MarkMessageCommand.MARK_AS_NOTRECENT: {
684             flags.setRecent(false);
685
686             break;
687         }
688         }
689         setChanged(true);
690
691         header.setFlags(flags);
692         getHeaderList().update(uid, header);
693
694         fireMessageFlagChanged(uid, oldFlags, variant);
695     }
696
697     /**
698      * @see org.columba.mail.folder.IMailbox#markMessage(java.lang.Object[],
699      * int)
700      */
701     public void markMessage(Object [] uids, int variant) throws Exception {
702         for (int i = 0; i < uids.length; i++) {
703             if (exists(uids[i])) {
704                 markMessage(uids[i], variant);
705
706             }
707         }
708     }
709
710     /** {@inheritDoc} */
711     public void expungeFolder() throws Exception {
712
713         // get list of all uids
714 Object [] uids = getUids();
715
716         for (int i = 0; i < uids.length; i++) {
717             Object uid = uids[i];
718
719             if (uid == null) {
720                 continue;
721             }
722
723             // if message with uid doesn't exist -> skip
724 if (!exists(uid)) {
725                 LOG.info("uid " + uid + " doesn't exist");
726
727                 continue;
728             }
729
730             if (getFlags(uid).getDeleted()) {
731                 // move message to trash if marked as expunged
732 LOG.info("removing uid=" + uid);
733
734                 // remove message
735 removeMessage(uid);
736             }
737         }
738     }
739
740     /**
741      * Remove message from folder.
742      * <p>
743      *
744      * @author: fdietz This method was intentionally changed to public also it
745      * isn't accessed from outside. This is why it isn't found in
746      * IMailbox. Only the VirtualFolder uses this public call.
747      *
748      *
749      * @param uid
750      * UID identifying the message to remove
751      * @throws Exception
752      */
753     public void removeMessage(Object uid) throws Exception {
754         // remove from header-list
755 IColumbaHeader header = getHeaderList().remove(uid);
756
757         // notify listeners
758 fireMessageRemoved(uid, header.getFlags());
759     }
760
761     /** ****************************** IAttributeStorage *********************** */
762
763     /**
764      * @return Returns the attributeStorage.
765      */
766     // public abstract IHeaderListStorage getHeaderListStorage();
767 /**
768      * @see org.columba.mail.folder.IMailbox#exists(java.lang.Object)
769      */
770     public boolean exists(Object uid) throws Exception {
771         return getHeaderList().exists(uid);
772     }
773
774     /**
775      * @see org.columba.mail.folder.IMailbox#getUids()
776      */
777     public Object [] getUids() throws Exception {
778         return getHeaderList().getUids();
779     }
780
781     /**
782      * @see org.columba.mail.folder.IMailbox#setAttribute(java.lang.Object,
783      * java.lang.String, java.lang.Object)
784      */
785     public void setAttribute(Object uid, String key, Object value)
786             throws Exception {
787
788         IColumbaHeader header = getHeaderList().get(uid);
789
790         header.getAttributes().put(key, value);
791
792         getHeaderList().update(uid, header);
793
794         // set folder changed flag
795 // -> if not, the header cache wouldn't notice that something
796 // -> has changed. And wouldn't save the changes.
797 setChanged(true);
798     }
799
800     /**
801      * @see org.columba.mail.folder.IMailbox#getFlags(java.lang.Object)
802      */
803     public Flags getFlags(Object uid) throws Exception {
804         return getHeaderList().get(uid).getFlags();
805     }
806
807     /**
808      * @see org.columba.mail.folder.IMailbox#getAttributes(java.lang.Object)
809      */
810     public Attributes getAttributes(Object uid) throws Exception {
811         return getHeaderList().get(uid).getAttributes();
812     }
813
814     /**
815      * @see org.columba.mail.folder.IMailbox#getAttribute(java.lang.Object,
816      * java.lang.String)
817      */
818     public Object getAttribute(Object uid, String key) throws Exception {
819         return getHeaderList().get(uid).getAttributes().get(key);
820     }
821
822     /**
823      * @return
824      */
825     public DefaultSearchEngine getSearchEngine() {
826         return this.searchEngine;
827     }
828
829     /**
830      * @param filter
831      * @param uids
832      * @return
833      * @throws Exception
834      */
835     public Object [] searchMessages(IFilter filter, Object [] uids)
836             throws Exception {
837         // if there is no search engine, try the default one
838 if (getSearchEngine() == null)
839             return (new DefaultSearchEngine(this)).searchMessages(filter, uids);
840         return getSearchEngine().searchMessages(filter, uids);
841     }
842
843     /**
844      * @param filter
845      * @return
846      * @throws Exception
847      */
848     public Object [] searchMessages(IFilter filter) throws Exception {
849         // if there is no search engine, try the default one
850 if (getSearchEngine() == null)
851             return (new DefaultSearchEngine(this)).searchMessages(filter);
852         return getSearchEngine().searchMessages(filter);
853     }
854
855     /**
856      * Set new search engine
857      *
858      * @see org.columba.mail.folder.search
859      *
860      * @param engine
861      * new search engine
862      */
863     public void setSearchEngine(DefaultSearchEngine engine) {
864         this.searchEngine = engine;
865     }
866
867     /**
868      * TODO (@author fdietz): move this out-of-folder!
869      *
870      * @param header
871      * @param bodyStream
872      * @return
873      */
874     protected InputStream decodeStream(MimeHeader header, InputStream bodyStream) {
875         String charsetName = header.getContentParameter("charset");
876         int encoding = header.getContentTransferEncoding();
877
878         switch (encoding) {
879         case MimeHeader.QUOTED_PRINTABLE: {
880             bodyStream = new QuotedPrintableDecoderInputStream(bodyStream);
881
882             break;
883         }
884
885         case MimeHeader.BASE64: {
886             bodyStream = new Base64DecoderInputStream(bodyStream);
887
888             break;
889         }
890         }
891
892         if (charsetName != null) {
893             Charset charset;
894
895             try {
896                 charset = Charset.forName(charsetName);
897             } catch (UnsupportedCharsetException e) {
898                 charset = Charset.forName(System.getProperty("file.encoding"));
899             }
900
901             bodyStream = new CharsetDecoderInputStream(bodyStream, charset);
902         }
903
904         return bodyStream;
905     }
906
907     /**
908      * @see org.columba.mail.folder.IMailbox#isReadOnly()
909      */
910     public boolean isReadOnly() {
911         return false;
912     }
913
914     /**
915      * @return Returns the headerList.
916      */
917     public abstract IHeaderList getHeaderList() throws Exception ;
918
919 }

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags