001: /*
002: * $RCSfile: FacilityManager.java,v $
003: * $Revision: 1.1 $
004: * $Date: 2005/02/11 05:02:25 $
005: * $State: Exp $
006: *
007: * Class: MsgLoggerManager
008: *
009: * Description: Manages common facilities across threads
010: *
011: *
012: *
013: * COPYRIGHT:
014: *
015: * This software module was originally developed by Raphaël Grosbois and
016: * Diego Santa Cruz (Swiss Federal Institute of Technology-EPFL); Joel
017: * Askelöf (Ericsson Radio Systems AB); and Bertrand Berthelot, David
018: * Bouchard, Félix Henry, Gerard Mozelle and Patrice Onno (Canon Research
019: * Centre France S.A) in the course of development of the JPEG2000
020: * standard as specified by ISO/IEC 15444 (JPEG 2000 Standard). This
021: * software module is an implementation of a part of the JPEG 2000
022: * Standard. Swiss Federal Institute of Technology-EPFL, Ericsson Radio
023: * Systems AB and Canon Research Centre France S.A (collectively JJ2000
024: * Partners) agree not to assert against ISO/IEC and users of the JPEG
025: * 2000 Standard (Users) any of their rights under the copyright, not
026: * including other intellectual property rights, for this software module
027: * with respect to the usage by ISO/IEC and Users of this software module
028: * or modifications thereof for use in hardware or software products
029: * claiming conformance to the JPEG 2000 Standard. Those intending to use
030: * this software module in hardware or software products are advised that
031: * their use may infringe existing patents. The original developers of
032: * this software module, JJ2000 Partners and ISO/IEC assume no liability
033: * for use of this software module or modifications thereof. No license
034: * or right to this software module is granted for non JPEG 2000 Standard
035: * conforming products. JJ2000 Partners have full right to use this
036: * software module for his/her own purpose, assign or donate this
037: * software module to any third party and to inhibit third parties from
038: * using this software module for non JPEG 2000 Standard conforming
039: * products. This copyright notice must be included in all copies or
040: * derivative works of this software module.
041: *
042: * Copyright (c) 1999/2000 JJ2000 Partners.
043: *
044: *
045: *
046: */
047:
048: package jj2000.j2k.util;
049:
050: import java.util.*;
051: import java.io.*;
052:
053: /**
054: * This class manages common facilities for mutithreading environments, It can
055: * register different facilities for each thread, and also a default one, so
056: * that they can be referred by static methods, while possibly having
057: * different ones for different threads. Also a default facility exists that
058: * is used for threads for which no particular facility has been registerd
059: * registered.
060: *
061: * <P>Currently the only kind of facilities managed is MsgLogger.
062: *
063: * <P>An example use of this class is if 2 instances of a decoder are running
064: * in different threads and the messages of the 2 instances should be
065: * separated.
066: *
067: * <P>The default MsgLogger is a StreamMsgLogger that uses System.out as
068: * the 'out' stream and System.err as the 'err' stream, and a line width of
069: * 78. This can be changed using the registerMsgLogger() method.
070: *
071: * @see MsgLogger
072: *
073: * @see StreamMsgLogger
074: * */
075: public class FacilityManager {
076:
077: /** The loggers associated to different threads */
078: private final static Hashtable loggerList = new Hashtable();
079:
080: /** The default logger, for threads that have none associated with them */
081: private static MsgLogger defMsgLogger = new StreamMsgLogger(
082: System.out, System.err, 78);
083:
084: /** The ProgressWatch instance associated to different threads */
085: private final static Hashtable watchProgList = new Hashtable();
086:
087: /** The default ProgressWatch for threads that have none
088: * associated with them. */
089: private static ProgressWatch defWatchProg = null;
090:
091: /** */
092: public static void registerProgressWatch(Thread t, ProgressWatch pw) {
093: if (pw == null) {
094: throw new NullPointerException();
095: }
096: if (t == null) {
097: defWatchProg = pw;
098: } else {
099: watchProgList.put(t, pw);
100: }
101: }
102:
103: /**
104: * Returns the ProgressWatch instance registered with the current
105: * thread (the thread that calls this method). If the current
106: * thread has no registered ProgressWatch, then the default one is used.
107: * */
108: public static ProgressWatch getProgressWatch() {
109: ProgressWatch pw = (ProgressWatch) watchProgList.get(Thread
110: .currentThread());
111: return (pw == null) ? defWatchProg : pw;
112: }
113:
114: /**
115: * Registers the MsgLogger 'ml' as the logging facility of the
116: * thread 't'. If any other logging facility was registered with the
117: * thread 't' it is overriden by 'ml'. If 't' is null then 'ml' is taken
118: * as the default message logger that is used for threads that have no
119: * MsgLogger registered.
120: *
121: * @param t The thread to associate with 'ml'
122: *
123: * @param ml The MsgLogger to associate with therad ml
124: * */
125: public static void registerMsgLogger(Thread t, MsgLogger ml) {
126: if (ml == null) {
127: throw new NullPointerException();
128: }
129: if (t == null) {
130: defMsgLogger = ml;
131: } else {
132: loggerList.put(t, ml);
133: }
134: }
135:
136: /**
137: * Returns the MsgLogger registered with the current thread (the
138: * thread that calls this method). If the current thread has no registered
139: * MsgLogger then the default message logger is returned.
140: *
141: * @return The MsgLogger registerd for the current thread, or the
142: * default one if there is none registered for it.
143: *
144: *
145: * */
146: public static MsgLogger getMsgLogger() {
147: MsgLogger ml = (MsgLogger) loggerList.get(Thread
148: .currentThread());
149: return (ml == null) ? defMsgLogger : ml;
150: }
151:
152: /**
153: * Returns the MsgLogger registered with the thread 't' (the thread
154: * that calls this method). If the thread 't' has no registered
155: * MsgLogger then the default message logger is returned.
156: *
157: * @param t The thread for which to return the MsgLogger
158: *
159: * @return The MsgLogger registerd for the current thread, or the
160: * default one if there is none registered for it.
161: *
162: *
163: * */
164: public static MsgLogger getMsgLogger(Thread t) {
165: MsgLogger ml = (MsgLogger) loggerList.get(t);
166: return (ml == null) ? defMsgLogger : ml;
167: }
168: }
|