View Javadoc

1   // ========================================================================
2   // Copyright 1999-2005 Mort Bay Consulting Pty. Ltd.
3   // ------------------------------------------------------------------------
4   // Licensed under the Apache License, Version 2.0 (the "License");
5   // you may not use this file except in compliance with the License.
6   // You may obtain a copy of the License at 
7   // http://www.apache.org/licenses/LICENSE-2.0
8   // Unless required by applicable law or agreed to in writing, software
9   // distributed under the License is distributed on an "AS IS" BASIS,
10  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11  // See the License for the specific language governing permissions and
12  // limitations under the License.
13  // ========================================================================
14  
15  package org.mortbay.util;
16  import java.io.PrintStream;
17  import java.io.PrintWriter;
18  import java.util.List;
19  
20  
21  /* ------------------------------------------------------------ */
22  /** Wraps multiple exceptions.
23   *
24   * Allows multiple exceptions to be thrown as a single exception.
25   *
26   * @author Greg Wilkins (gregw)
27   */
28  public class MultiException extends Exception
29  {
30      private Object nested;
31  
32      /* ------------------------------------------------------------ */
33      public MultiException()
34      {
35          super("Multiple exceptions");
36      }
37  
38      /* ------------------------------------------------------------ */
39      public void add(Throwable e)
40      {
41          if (e instanceof MultiException)
42          {
43              MultiException me = (MultiException)e;
44              for (int i=0;i<LazyList.size(me.nested);i++)
45                  nested=LazyList.add(nested,LazyList.get(me.nested,i));
46          }
47          else
48              nested=LazyList.add(nested,e);
49      }
50  
51      /* ------------------------------------------------------------ */
52      public int size()
53      {
54          return LazyList.size(nested);
55      }
56      
57      /* ------------------------------------------------------------ */
58      public List getThrowables()
59      {
60          return LazyList.getList(nested);
61      }
62      
63      /* ------------------------------------------------------------ */
64      public Throwable getThrowable(int i)
65      {
66          return (Throwable) LazyList.get(nested,i);
67      }
68  
69      /* ------------------------------------------------------------ */
70      /** Throw a multiexception.
71       * If this multi exception is empty then no action is taken. If it
72       * contains a single exception that is thrown, otherwise the this
73       * multi exception is thrown. 
74       * @exception Exception 
75       */
76      public void ifExceptionThrow()
77          throws Exception
78      {
79          switch (LazyList.size(nested))
80          {
81            case 0:
82                break;
83            case 1:
84                Throwable th=(Throwable)LazyList.get(nested,0);
85                if (th instanceof Error)
86                    throw (Error)th;
87                if (th instanceof Exception)
88                    throw (Exception)th;
89            default:
90                throw this;
91          }
92      }
93      
94      /* ------------------------------------------------------------ */
95      /** Throw a Runtime exception.
96       * If this multi exception is empty then no action is taken. If it
97       * contains a single error or runtime exception that is thrown, otherwise the this
98       * multi exception is thrown, wrapped in a runtime exception. 
99       * @exception Error If this exception contains exactly 1 {@link Error} 
100      * @exception RuntimeException If this exception contains 1 {@link Throwable} but it is not an error,
101      *                             or it contains more than 1 {@link Throwable} of any type.
102      */
103     public void ifExceptionThrowRuntime()
104         throws Error
105     {
106         switch (LazyList.size(nested))
107         {
108           case 0:
109               break;
110           case 1:
111               Throwable th=(Throwable)LazyList.get(nested,0);
112               if (th instanceof Error)
113                   throw (Error)th;
114               else if (th instanceof RuntimeException)
115                   throw (RuntimeException)th;
116               else
117                   throw new RuntimeException(th);
118           default:
119               throw new RuntimeException(this);
120         }
121     }
122     
123     /* ------------------------------------------------------------ */
124     /** Throw a multiexception.
125      * If this multi exception is empty then no action is taken. If it
126      * contains a any exceptions then this
127      * multi exception is thrown. 
128      */
129     public void ifExceptionThrowMulti()
130         throws MultiException
131     {
132         if (LazyList.size(nested)>0)
133             throw this;
134     }
135 
136     /* ------------------------------------------------------------ */
137     public String toString()
138     {
139         if (LazyList.size(nested)>0)
140             return "org.mortbay.util.MultiException"+
141                 LazyList.getList(nested);
142         return "org.mortbay.util.MultiException[]";
143     }
144 
145     /* ------------------------------------------------------------ */
146     public void printStackTrace()
147     {
148         super.printStackTrace();
149         for (int i=0;i<LazyList.size(nested);i++)
150             ((Throwable)LazyList.get(nested,i)).printStackTrace();
151     }
152    
153 
154     /* ------------------------------------------------------------------------------- */
155     /**
156      * @see java.lang.Throwable#printStackTrace(java.io.PrintStream)
157      */
158     public void printStackTrace(PrintStream out)
159     {
160         super.printStackTrace(out);
161         for (int i=0;i<LazyList.size(nested);i++)
162             ((Throwable)LazyList.get(nested,i)).printStackTrace(out);
163     }
164 
165     /* ------------------------------------------------------------------------------- */
166     /**
167      * @see java.lang.Throwable#printStackTrace(java.io.PrintWriter)
168      */
169     public void printStackTrace(PrintWriter out)
170     {
171         super.printStackTrace(out);
172         for (int i=0;i<LazyList.size(nested);i++)
173             ((Throwable)LazyList.get(nested,i)).printStackTrace(out);
174     }
175 
176 }