blob: e9208fbc63d1c1c27a0c374a1ec569ba330dc792 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.events;
import java.util.Iterator;
import java.util.Map;
import org.apache.xmlgraphics.util.Service;
/**
* This class is responsible for converting events into exceptions.
*/
public final class EventExceptionManager {
private EventExceptionManager() {
}
private static final Map<String, ExceptionFactory> EXCEPTION_FACTORIES
= new java.util.HashMap<String, ExceptionFactory>();
static {
Iterator<Object> iter;
iter = Service.providers(ExceptionFactory.class);
while (iter.hasNext()) {
ExceptionFactory factory = (ExceptionFactory)iter.next();
EXCEPTION_FACTORIES.put(factory.getExceptionClass().getName(), factory);
}
}
/**
* Converts an event into an exception and throws that. If the exception class is null,
* a {@link RuntimeException} will be thrown.
* @param event the event to be converted
* @param exceptionClass the exception class to be thrown
* @throws Throwable this happens always
*/
public static void throwException(Event event, String exceptionClass) throws Throwable {
if (exceptionClass != null) {
ExceptionFactory factory = EXCEPTION_FACTORIES.get(exceptionClass);
if (factory != null) {
throw factory.createException(event);
} else {
throw new IllegalArgumentException(
"No such ExceptionFactory available: " + exceptionClass);
}
} else {
String msg = EventFormatter.format(event);
//Get original exception as cause if it is given as one of the parameters
Throwable t = null;
Iterator<Object> iter = event.getParams().values().iterator();
while (iter.hasNext()) {
Object o = iter.next();
if (o instanceof Throwable) {
t = (Throwable)o;
break;
}
}
if (t != null) {
throw new RuntimeException(msg, t);
} else {
throw new RuntimeException(msg);
}
}
}
/**
* This interface is implementation by exception factories that can create exceptions from
* events.
*/
public interface ExceptionFactory {
/**
* Creates an exception from an event.
* @param event the event
* @return the newly created exception
*/
Throwable createException(Event event);
/**
* Returns the {@link Exception} class created by this factory.
* @return the exception class
*/
Class<? extends Exception> getExceptionClass();
}
}
|
