libjava/java/util/logging/ErrorManager.java

   1 /* ErrorManager.java --
   2    A class for dealing with errors that a Handler encounters
   3    during logging
   4    Copyright (C) 2002, 2003 Free Software Foundation, Inc.
   5
   6 This file is part of GNU Classpath.
   7
   8 GNU Classpath is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU Classpath is distributed in the hope that it will be useful, but
  14 WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Classpath; see the file COPYING.  If not, write to the
  20 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  21 02111-1307 USA.
  22
  23 Linking this library statically or dynamically with other modules is
  24 making a combined work based on this library.  Thus, the terms and
  25 conditions of the GNU General Public License cover the whole
  26 combination.
  27
  28 As a special exception, the copyright holders of this library give you
  29 permission to link this library with independent modules to produce an
  30 executable, regardless of the license terms of these independent
  31 modules, and to copy and distribute the resulting executable under
  32 terms of your choice, provided that you also meet, for each linked
  33 independent module, the terms and conditions of the license of that
  34 module.  An independent module is a module which is not derived from
  35 or based on this library.  If you modify this library, you may extend
  36 this exception to your version of the library, but you are not
  37 obligated to do so.  If you do not wish to do so, delete this
  38 exception statement from your version. */
  39
  40
  41 package java.util.logging;
  42
  43 /**
  44  * An <code>ErrorManager</code> deals with errors that a <code>Handler</code>
  45  * encounters while logging.
  46  *
  47  * @see Handler#setErrorManager(ErrorManager)
  48  *
  49  * @author Sascha Brawer (brawer@acm.org)
  50  */
  51 public class ErrorManager
  52 {
  53   /* The values have been taken from Sun's public J2SE 1.4 API
  54    * documentation.
  55    * See http://java.sun.com/j2se/1.4/docs/api/constant-values.html
  56    */
  57
  58   /**
  59    * Indicates that there was a failure that does not readily
  60    * fall into any of the other categories.
  61    */
  62   public static final int GENERIC_FAILURE = 0;
  63
  64
  65   /**
  66    * Indicates that there was a problem upon writing to
  67    * an output stream.
  68    */
  69   public static final int WRITE_FAILURE = 1;
  70
  71
  72   /**
  73    * Indicates that there was a problem upon flushing
  74    * an output stream.
  75    */
  76   public static final int FLUSH_FAILURE = 2;
  77
  78
  79   /**
  80    * Indicates that there was a problem upon closing
  81    * an output stream.
  82    */
  83   public static final int CLOSE_FAILURE = 3;
  84
  85
  86   /**
  87    * Indicates that there was a problem upon opening
  88    * an output stream.
  89    */
  90   public static final int OPEN_FAILURE = 4;
  91
  92
  93   /**
  94    * Indicates that there was a problem upon formatting
  95    * the message of a log record.
  96    */
  97   public static final int FORMAT_FAILURE = 5;
  98
  99
 100   /**
 101    * Indicates whether the {@link #error} method of this ErrorManager
 102    * has ever been used.
 103    *
 104    * Declared volatile in order to correctly support the
 105    * double-checked locking idiom (once the revised Java Memory Model
 106    * gets adopted); see Classpath bug #2944.
 107    */
 108   private volatile boolean everUsed = false;
 109
 110
 111   public ErrorManager()
 112   {
 113   }
 114
 115
 116   /**
 117    * Reports an error that occured upon logging.  The default implementation
 118    * emits the very first error to System.err, ignoring subsequent errors.
 119    *
 120    * @param message a message describing the error, or <code>null</code> if
 121    *                there is no suitable description.
 122    *
 123    * @param ex      an exception, or <code>null</code> if the error is not
 124    *                related to an exception.
 125    *
 126    * @param errorCode  one of the defined error codes, for example
 127    *                   <code>ErrorManager.CLOSE_FAILURE</code>.
 128    */
 129   public void error(String message, Exception ex, int errorCode)
 130   {
 131     if (everUsed)
 132       return;
 133
 134     synchronized (this)
 135     {
 136       /* The double check is intentional. If the first check was
 137        * omitted, the monitor would have to be entered every time
 138        * error() method was called. If the second check was
 139        * omitted, the code below could be executed by multiple
 140        * threads simultaneously.
 141        *
 142        * This is the 'double-checked locking' idiom, which is broken
 143        * with the current version of the Java memory model.  However,
 144        * we assume that JVMs will have adopted a revised version of
 145        * the Java Memory Model by the time GNU Classpath gains
 146        * widespread acceptance. See Classpath bug #2944.
 147        */
 148       if (everUsed)
 149         return;
 150
 151       everUsed = true;
 152     }
 153
 154     String codeMsg;
 155     switch (errorCode)
 156     {
 157     case GENERIC_FAILURE:
 158       codeMsg = "GENERIC_FAILURE";
 159       break;
 160
 161     case WRITE_FAILURE:
 162       codeMsg = "WRITE_FAILURE";
 163       break;
 164
 165     case FLUSH_FAILURE:
 166       codeMsg = "FLUSH_FAILURE";
 167       break;
 168
 169     case CLOSE_FAILURE:
 170       codeMsg = "CLOSE_FAILURE";
 171       break;
 172
 173     case OPEN_FAILURE:
 174       codeMsg = "OPEN_FAILURE";
 175       break;
 176
 177     case FORMAT_FAILURE:
 178       codeMsg = "FORMAT_FAILURE";
 179       break;
 180
 181     default:
 182       codeMsg = String.valueOf(errorCode);
 183       break;
 184     }
 185
 186     System.err.println("Error upon logging: " + codeMsg);
 187     if ((message != null) && (message.length() > 0))
 188       System.err.println(message);
 189
 190     if (ex != null)
 191       ex.printStackTrace();
 192   }
 193 }
 194