/**
* Alipay.com Inc.
* Copyright (c) 2004-2012 All Rights Reserved.
*/
package com.alipay.zdal.datasource.resource.util;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import org.apache.log4j.Logger;
import com.alipay.zdal.datasource.resource.util.platform.Java;
/**
* Interface which is implemented by all the nested throwable flavors.
*
*
* @author ����
* @version $Id: NestedThrowable.java, v 0.1 2014-1-6 ����05:39:40 Exp $
*/
public interface NestedThrowable extends Serializable {
/**
* A system wide flag to enable or disable printing of the
* parent throwable traces.
*
* <p>
* This value is set from the system property
* <tt>org.jboss.util.NestedThrowable.parentTraceEnabled</tt>
* or if that is not set defaults to <tt>true</tt>.
*/
boolean PARENT_TRACE_ENABLED = Util.getBoolean("parentTraceEnabled", true);
/**
* A system wide flag to enable or disable printing of the
* nested detail throwable traces.
*
* <p>
* This value is set from the system property
* <tt>org.jboss.util.NestedThrowable.nestedTraceEnabled</tt>
* or if that is not set defaults to <tt>true</tt> unless
* using JDK 1.4 with {@link #PARENT_TRACE_ENABLED} set to false,
* then <tt>false</tt> since there is a native mechansim for this there.
*
* <p>
* Note then when running under 1.4 is is not possible to disable
* the nested trace output, since that is handled by java.lang.Throwable
* which we delegate the parent printing to.
*/
boolean NESTED_TRACE_ENABLED = Util
.getBoolean(
"nestedTraceEnabled",
(Java.isCompatible(Java.VERSION_1_4) && !PARENT_TRACE_ENABLED)
|| !Java.isCompatible(Java.VERSION_1_4));
/**
* A system wide flag to enable or disable checking of parent and child
* types to detect uneeded nesting
*
* <p>
* This value is set from the system property
* <tt>org.jboss.util.NestedThrowable.detectDuplicateNesting</tt>
* or if that is not set defaults to <tt>true</tt>.
*/
boolean DETECT_DUPLICATE_NESTING = Util.getBoolean("detectDuplicateNesting", true);
/**
* Return the nested throwable.
*
* @return Nested throwable.
*/
Throwable getNested();
/**
* Return the nested <tt>Throwable</tt>.
*
* <p>For JDK 1.4 compatibility.
*
* @return Nested <tt>Throwable</tt>.
*/
Throwable getCause();
/////////////////////////////////////////////////////////////////////////
// Nested Throwable Utilities //
/////////////////////////////////////////////////////////////////////////
/**
* Utilitiy methods for the various flavors of
* <code>NestedThrowable</code>.
*/
final class Util {
// Can not be final due to init bug, see getLogger() for details
private static Logger log = Logger.getLogger(NestedThrowable.class);
/**
* Something is very broken with class nesting, which can sometimes
* leave log uninitialized durring one of the following method calls.
*
* <p>
* This is a HACK to keep those methods from NPE until this problem
* can be resolved.
*/
private static Logger getLogger() {
return log;
}
/** A helper to get a boolean property. */
protected static boolean getBoolean(String name, boolean defaultValue) {
name = NestedThrowable.class.getName() + "." + name;
String value = System.getProperty(name, String.valueOf(defaultValue));
// HACK see getLogger() for details
log = getLogger();
log.debug(name + "=" + value);
return new Boolean(value).booleanValue();
}
/**
* Check and possibly warn if the nested exception type is the same
* as the parent type (duplicate nesting).
*/
public static void checkNested(final NestedThrowable parent, final Throwable child) {
if (!DETECT_DUPLICATE_NESTING || parent == null || child == null)
return;
Class parentType = parent.getClass();
Class childType = child.getClass();
//
// This might be backwards... I always get this confused
//
if (parentType.isAssignableFrom(childType)) {
// HACK see getLogger() for details
log = getLogger();
log.warn("Duplicate throwable nesting of same base type: " + parentType
+ " is assignable from: " + childType);
}
}
/**
* Returns a formated message for the given detail message
* and nested <code>Throwable</code>.
*
* @param msg Detail message.
* @param nested Nested <code>Throwable</code>.
* @return Formatted message.
*/
public static String getMessage(final String msg, final Throwable nested) {
StringBuffer buff = new StringBuffer(msg == null ? "" : msg);
if (nested != null) {
buff.append(msg == null ? "- " : "; - ").append("nested throwable: (").append(
nested).append(")");
}
return buff.toString();
}
/**
* Prints the nested <code>Throwable</code> to the given stream.
*
* @param nested Nested <code>Throwable</code>.
* @param stream Stream to print to.
*/
public static void print(final Throwable nested, final PrintStream stream) {
if (stream == null)
throw new NullArgumentException("stream");
if (NestedThrowable.NESTED_TRACE_ENABLED && nested != null) {
synchronized (stream) {
if (NestedThrowable.PARENT_TRACE_ENABLED) {
stream.print(" + nested throwable: ");
} else {
stream.print("[ parent trace omitted ]: ");
}
nested.printStackTrace(stream);
}
}
}
/**
* Prints the nested <code>Throwable</code> to the given writer.
*
* @param nested Nested <code>Throwable</code>.
* @param writer Writer to print to.
*/
public static void print(final Throwable nested, final PrintWriter writer) {
if (writer == null)
throw new NullArgumentException("writer");
if (NestedThrowable.NESTED_TRACE_ENABLED && nested != null) {
synchronized (writer) {
if (NestedThrowable.PARENT_TRACE_ENABLED) {
writer.print(" + nested throwable: ");
} else {
writer.print("[ parent trace omitted ]: ");
}
nested.printStackTrace(writer);
}
}
}
}
}