examples/org.eclipse.ocl.examples.debug.vm/src/org/eclipse/ocl/examples/debug/vm/utils/Trace.java - ocl/org.eclipse.ocl - Git at Google

 /*******************************************************************************
  * Copyright (c) 2014, 2018 Willink Transformations and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *     R.Dvorak and others - QVTo debugger framework
  *     E.D.Willink - revised API for OCL debugger framework
  *******************************************************************************/
 package org.eclipse.ocl.examples.debug.vm.utils;

 import java.util.HashMap;
 import java.util.Map;

 import org.eclipse.core.runtime.Plugin;
 import org.eclipse.jdt.annotation.NonNull;


 public class Trace {

 	/**
 	 * String containing an open parenthesis.
 	 *
 	 */
 	protected static final String PARENTHESIS_OPEN = "("; //$NON-NLS-1$

 	/**
 	 * String containing a close parenthesis.
 	 *
 	 */
 	protected static final String PARENTHESIS_CLOSE = ")"; //$NON-NLS-1$

 	/**
 	 * Prefix for tracing the changing of values.
 	 *
 	 */
 	protected static final String PREFIX_CHANGING = "CHANGING "; //$NON-NLS-1$

 	/**
 	 * Prefix for tracing the catching of throwables.
 	 *
 	 */
 	protected static final String PREFIX_CATCHING = "CAUGHT "; //$NON-NLS-1$

 	/**
 	 * Prefix for tracing the throwing of throwables.
 	 *
 	 */
 	protected static final String PREFIX_THROWING = "THROWN "; //$NON-NLS-1$

 	/**
 	 * Prefix for tracing the entering of methods.
 	 *
 	 */
 	protected static final String PREFIX_ENTERING = "ENTERING "; //$NON-NLS-1$

 	/**
 	 * Prefix for tracing the exiting of methods.
 	 *
 	 */
 	protected static final String PREFIX_EXITING = "EXITING "; //$NON-NLS-1$

 	/**
 	 * Separator for methods.
 	 *
 	 */
 	protected static final String SEPARATOR_METHOD = "#"; //$NON-NLS-1$

 	/**
 	 * Separator for parameters.
 	 *
 	 */
 	protected static final String SEPARATOR_PARAMETER = ", "; //$NON-NLS-1$

 	/**
 	 * Separator for return values.
 	 *
 	 */
 	protected static final String SEPARATOR_RETURN = ":"; //$NON-NLS-1$

 	/**
 	 * Separator containing a space.
 	 *
 	 */
 	protected static final String SEPARATOR_SPACE = " "; //$NON-NLS-1$

 	/**
 	 * Label indicating old value.
 	 *
 	 */
 	protected static final String LABEL_OLD_VALUE = "old="; //$NON-NLS-1$

 	/**
 	 * Label indicating new value.
 	 *
 	 */
 	protected static final String LABEL_NEW_VALUE = "new="; //$NON-NLS-1$

 	protected final @NonNull String exceptionsCatchingOption;
 	protected final @NonNull String exceptionsThrowingOption;
 	protected final @NonNull String methodsEnteringOption;
 	protected final @NonNull String methodsExitingOption;
 	private Tracing fTracing;


 	public Trace(@NonNull String exceptionsCatchingOption, @NonNull String exceptionsThrowingOption,
 			@NonNull String methodsEnteringOption, @NonNull String methodsExitingOption) {
 		this.exceptionsCatchingOption = exceptionsCatchingOption;
 		this.exceptionsThrowingOption = exceptionsThrowingOption;
 		this.methodsEnteringOption = methodsEnteringOption;
 		this.methodsExitingOption = methodsExitingOption;
 		fTracing = new Tracing();
 	}

 	protected void start(Plugin plugin) {
 		fTracing.start(plugin);
 	}

 	protected void stop() {
 		fTracing.stop();
 	}

 	/**
 	 * Queries whether method entry tracing is enabled.
 	 *
 	 * @return whether method entry tracing is enabled
 	 */
 	public boolean shouldTraceEntering() {
 		return shouldTrace(methodsEnteringOption);
 	}

 	/**
 	 * Queries whether method entry tracing is enabled for the specified
 	 * debug option.
 	 *
 	 * @param option the debug option to test
 	 * @return whether method entry tracing is enabled for the option
 	 */
 	public boolean shouldTraceEntering(String option) {
 		return shouldTraceEntering() && shouldTrace(option);
 	}

 	/**
 	 * Queries whether method exit tracing is enabled.
 	 *
 	 * @return whether method exit tracing is enabled
 	 */
 	public boolean shouldTraceExiting() {
 		return fTracing.shouldTrace(methodsExitingOption);
 	}

 	/**
 	 * Queries whether method exit tracing is enabled for the specified
 	 * debug option.
 	 *
 	 * @param option the debug option to test
 	 * @return whether method exit tracing is enabled for the option
 	 */
 	public boolean shouldTraceExiting(String option) {
 		return shouldTraceExiting() && fTracing.shouldTrace(option);
 	}

 	/**
 	 * Queries whether exception catch tracing is enabled.
 	 *
 	 * @return whether exception catch tracing is enabled
 	 */
 	public boolean shouldTraceCatching() {
 		return fTracing.shouldTrace(exceptionsCatchingOption);
 	}

 	/**
 	 * Queries whether exception throw tracing is enabled.
 	 *
 	 * @return whether exception throw tracing is enabled
 	 */
 	public boolean shouldTraceThrowing() {
 		return fTracing.shouldTrace(exceptionsThrowingOption);
 	}

 	/**
 	 * Queries whether tracing is enabled for the
 	 * specified debug option of this plug-in.
 	 *
 	 * @param option The debug option for which to determine trace enablement.
 	 * @return Whether tracing is enabled for the debug option of the plug-in.
 	 */
 	public boolean shouldTrace(String option) {
 		return fTracing.shouldTrace(
 				option);
 	}

 	/**
 	 * Traces the specified message from this plug-in.
 	 *
 	 * @param message The message to be traced.
 	 */
 	public void trace(String message) {
 		fTracing.trace(message);
 	}

 	/**
 	 * Traces the specified message from this plug-in for the specified
 	 * debug option.
 	 *
 	 * @param option The debug option for which to trace.
 	 * @param message The message to be traced.
 	 */
 	public void trace(String option, String message) {
 		fTracing.trace(
 				option,
 				message);
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class.
 	 *
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 */
 	public void entering(
 		Class<?> clazz,
 		String methodName) {

 		fTracing.entering(
 				methodsEnteringOption,
 				clazz,
 				methodName);
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class,
 	 * with the specified parameter.
 	 *
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 * @param parameter The parameter to the method being entered.
 	 */
 	public void entering(
 		Class<?> clazz,
 		String methodName,
 		Object parameter) {

 		fTracing.entering(
 				methodsEnteringOption,
 				clazz,
 				methodName,
 				parameter);
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class,
 	 * with the specified parameters.
 	 *
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 * @param parameters The parameters to the method being entered.
 	 */
 	public void entering(
 		Class<?> clazz,
 		String methodName,
 		Object[] parameters) {

 		fTracing.entering(
 				methodsEnteringOption,
 				clazz,
 				methodName,
 				parameters);
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class.
 	 *
 	 * @param option only trace entering if this option is enabled (in addition
 	 *    to the generic method-entry option)
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 */
 	public void entering(
 		String option,
 		Class<?> clazz,
 		String methodName) {

 		if (shouldTraceEntering()) {
 			fTracing.entering(
 					option,
 					clazz,
 					methodName);
 		}
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class,
 	 * with the specified parameter.
 	 *
 	 * @param option only trace entering if this option is enabled (in addition
 	 *    to the generic method-entry option)
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 * @param parameter The parameter to the method being entered.
 	 */
 	public void entering(
 		String option,
 		Class<?> clazz,
 		String methodName,
 		Object parameter) {

 		if (shouldTraceEntering()) {
 			fTracing.entering(
 					option,
 					clazz,
 					methodName,
 					parameter);
 		}
 	}

 	/**
 	 * Traces an entry into the specified method of the specified class,
 	 * with the specified parameters.
 	 *
 	 * @param option only trace entering if this option is enabled (in addition
 	 *    to the generic method-entry option)
 	 * @param clazz The class whose method is being entered.
 	 * @param methodName The name of method that is being entered.
 	 * @param parameters The parameters to the method being entered.
 	 */
 	public void entering(
 		String option,
 		Class<?> clazz,
 		String methodName,
 		Object[] parameters) {

 		if (shouldTraceEntering()) {
 			fTracing.entering(
 					option,
 					clazz,
 					methodName,
 					parameters);
 		}
 	}

 	/**
 	 * Traces an exit from the specified method of the specified class.
 	 *
 	 * @param clazz The class whose method is being exited.
 	 * @param methodName The name of method that is being exited.
 	 */
 	public void exiting(
 		Class<?> clazz,
 		String methodName) {

 		fTracing.exiting(
 				methodsExitingOption,
 				clazz,
 				methodName);
 	}

 	/**
 	 * Traces an exit from the specified method of the specified class,
 	 * with the specified return value.
 	 *
 	 * @param clazz The class whose method is being exited.
 	 * @param methodName The name of method that is being exited.
 	 * @param returnValue The return value of the method being exited.
 	 */
 	public void exiting(
 		Class<?> clazz,
 		String methodName,
 		Object returnValue) {

 		fTracing.exiting(
 				methodsExitingOption,
 				clazz,
 				methodName,
 				returnValue);
 	}

 	/**
 	 * Traces an exit from the specified method of the specified class.
 	 *
 	 * @param option only trace entering if this option is enabled (in addition
 	 *    to the generic method-exit option)
 	 * @param clazz The class whose method is being exited.
 	 * @param methodName The name of method that is being exited.
 	 */
 	public void exiting(
 		String option,
 		Class<?> clazz,
 		String methodName) {

 		if (shouldTraceExiting()) {
 			fTracing.exiting(
 					option,
 					clazz,
 					methodName);
 		}
 	}

 	/**
 	 * Traces an exit from the specified method of the specified class,
 	 * with the specified return value.
 	 *
 	 * @param option only trace entering if this option is enabled (in addition
 	 *    to the generic method-exit option)
 	 * @param clazz The class whose method is being exited.
 	 * @param methodName The name of method that is being exited.
 	 * @param returnValue The return value of the method being exited.
 	 */
 	public void exiting(
 		String option,
 		Class<?> clazz,
 		String methodName,
 		Object returnValue) {

 		if (shouldTraceExiting()) {
 			fTracing.exiting(
 					option,
 					clazz,
 					methodName,
 					returnValue);
 		}
 	}

 	/**
 	 * Traces the catching of the specified throwable in the specified method of
 	 * the specified class.
 	 *
 	 * @param clazz The class in which the throwable is being caught.
 	 * @param methodName The name of the method in which the throwable is being
 	 *                    caught.
 	 * @param throwable The throwable that is being caught.
 	 */
 	public void catching(
 		Class<?> clazz,
 		String methodName,
 		Throwable throwable) {

 		fTracing.catching(
 				exceptionsCatchingOption,
 				clazz,
 				methodName,
 				throwable);
 	}

 	/**
 	 * Traces the throwing of the specified throwable from the specified method
 	 * of the specified class.
 	 *
 	 * @param clazz The class from which the throwable is being thrown.
 	 * @param methodName The name of the method from which the throwable is
 	 *                    being thrown.
 	 * @param throwable The throwable that is being thrown.
 	 */
 	public void throwing(
 		Class<?> clazz,
 		String methodName,
 		Throwable throwable) {

 		fTracing.throwing(
 				exceptionsThrowingOption,
 				clazz,
 				methodName,
 				throwable);
 	}

 	/**
 	 * Converts an array of objects to a string for trace output.
 	 *
 	 * @param array the array to convert to a string
 	 * @return the string
 	 */
 	public static String toString(Object[] array) {
 		StringBuffer result = new StringBuffer(64);

 		result.append('[');

 		for (int i = 0; i < array.length; i++) {
 			if (i > 0) {
 				result.append(", "); //$NON-NLS-1$
 			}

 			result.append(array[i]);
 		}

 		result.append(']');

 		return result.toString();
 	}


     private class Tracing {

 		private Plugin fPlugin;

 		Tracing() {
 			super();
 		}

 		synchronized void start(Plugin plugin) {
 			fPlugin = plugin;
 		}

 		synchronized void stop() {
 			fPlugin = null;
 		}

     	/**
     	 * The cached debug options (for optimization).
     	 */
     	private final Map<String, Boolean> cachedOptions = new HashMap<String, Boolean>();

     	/**
     	 * Retrieves a Boolean value indicating whether tracing is enabled.
     	 *
     	 * @return Whether tracing is enabled for the plug-in.
     	 *
     	 */
     	protected synchronized boolean shouldTrace() {
     		return fPlugin != null && fPlugin.isDebugging();
     	}

     	/**
     	 * Retrieves a Boolean value indicating whether tracing is enabled for the
     	 * specified debug option.
     	 *
     	 * @return Whether tracing is enabled for the debug option of the plug-in.
     	 * @param option The debug option for which to determine trace enablement.
     	 *
     	 */
     	public boolean shouldTrace(String option) {
     		if (shouldTrace()) {
     			Boolean value = null;

     			synchronized (cachedOptions) {
     				value = cachedOptions.get(option);

     				if (null == value) {
     					value =
     						Boolean.valueOf(
     								org.eclipse.core.runtime.Platform.getDebugOption(option));

     					cachedOptions.put(option, value);
     				}
     			}

     			return value.booleanValue();
     		}

     		return false;
     	}

     	/**
     	 * Retrieves a textual representation of the specified argument.
     	 *
     	 * @return A textual representation of the specified argument.
     	 * @param argument The argument for which to retrieve a textual
     	 *                  representation.
     	 *
     	 */
     	protected String getArgumentString(Object argument) {
     		return String.valueOf(argument);
     	}

     	/**
     	 * Retrieves a textual representation of the specified arguments.
     	 *
     	 * @return A textual representation of the specified arguments.
     	 * @param arguments The arguments for which to retrieve a textual
     	 *                   representation.
     	 *
     	 */
     	protected String getArgumentsString(Object[] arguments) {
     		StringBuffer buffer = new StringBuffer();

     		for (int i = 0; i < arguments.length; i++) {
     			buffer.append(getArgumentString(arguments[i]));

     			if (i < arguments.length - 1) {
     				buffer.append(SEPARATOR_PARAMETER);
     			}
     		}

     		return buffer.toString();
     	}

     	/**
     	 * Traces the specified message.
     	 *
     	 * @param message The message to be traced.
     	 *
     	 */
     	public void trace(String message) {
     		if (shouldTrace()) {
     			System.out.println(message);
     		}
     	}

     	/**
     	 * Traces the specified message for the specified
     	 * debug option.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param message The message to be traced.
     	 *
     	 */
     	public void trace(String option, String message) {
     		if (shouldTrace(option)) {
     			trace(message);
     		}
     	}

     	/**
     	 * Traces the catching of the specified throwable in the specified method of
     	 * the specified class.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param clazz The class in which the throwable is being caught.
     	 * @param methodName The name of the method in which the throwable is being
     	 *                    caught.
     	 * @param throwable The throwable that is being caught.
     	 *
     	 */
     	public void catching(
     		String option,
     		Class<?> clazz,
     		String methodName,
     		Throwable throwable) {

     		if (shouldTrace(option)) {

     			trace(
     				PREFIX_CATCHING
     					+ throwable.getMessage()
     					+ SEPARATOR_SPACE
     					+ PARENTHESIS_OPEN
     					+ clazz.getName()
     					+ SEPARATOR_METHOD
     					+ methodName
     					+ PARENTHESIS_CLOSE);

     			throwable.printStackTrace(System.err);
     		}
     	}

     	/**
     	 * Traces the throwing of the specified throwable from the specified method
     	 * of the specified class.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param clazz The class from which the throwable is being thrown.
     	 * @param methodName The name of the method from which the throwable is
     	 *                    being thrown.
     	 * @param throwable The throwable that is being thrown.
     	 *
     	 */
     	public void throwing(
     		String option,
     		Class<?> clazz,
     		String methodName,
     		Throwable throwable) {

     		if (shouldTrace(option)) {

     			trace(
     				PREFIX_THROWING
     					+ throwable.getMessage()
     					+ SEPARATOR_SPACE
     					+ PARENTHESIS_OPEN
     					+ clazz.getName()
     					+ SEPARATOR_METHOD
     					+ methodName
     					+ PARENTHESIS_CLOSE);

     			throwable.printStackTrace(System.err);
     		}
     	}

     	/**
     	 * Traces the entering into the specified method of the specified class,
     	 * with the specified parameters.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param clazz The class whose method is being entered.
     	 * @param methodName The name of method that is being entered.
     	 * @param parameters The parameters to the method being entered.
     	 *
     	 */
     	public void entering(
     		String option,
     		Class<?> clazz,
     		String methodName,
     		Object... parameters) {

     		if (shouldTrace(option)) {

     			trace(
     				PREFIX_ENTERING
     					+ clazz.getName()
     					+ SEPARATOR_METHOD
     					+ methodName
     					+ PARENTHESIS_OPEN
     					+ getArgumentsString(parameters)
     					+ PARENTHESIS_CLOSE);
     		}
     	}

     	/**
     	 * Traces the exiting from the specified method of the specified class.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param clazz The class whose method is being exited.
     	 * @param methodName The name of method that is being exited.
     	 *
     	 */
     	public void exiting(
     		String option,
     		Class<?> clazz,
     		String methodName) {

     		if (shouldTrace(option)) {

     			trace(
     				PREFIX_EXITING
     					+ clazz.getName()
     					+ SEPARATOR_METHOD
     					+ methodName);
     		}
     	}

     	/**
     	 * Traces the exiting from the specified method of the specified class,
     	 * with the specified return value.
     	 *
     	 * @param option The debug option for which to trace.
     	 * @param clazz The class whose method is being exited.
     	 * @param methodName The name of method that is being exited.
     	 * @param returnValue The return value of the method being exited.
     	 *
     	 */
     	public void exiting(
     		String option,
     		Class<?> clazz,
     		String methodName,
     		Object returnValue) {

     		if (shouldTrace(option)) {

     			trace(
     				PREFIX_EXITING
     					+ clazz.getName()
     					+ SEPARATOR_METHOD
     					+ methodName
     					+ SEPARATOR_RETURN
     					+ getArgumentString(returnValue));
     		}
     	}
     }

 }
	/*******************************************************************************
	* Copyright (c) 2014, 2018 Willink Transformations and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* R.Dvorak and others - QVTo debugger framework
	* E.D.Willink - revised API for OCL debugger framework
	*******************************************************************************/
	package org.eclipse.ocl.examples.debug.vm.utils;

	import java.util.HashMap;
	import java.util.Map;

	import org.eclipse.core.runtime.Plugin;
	import org.eclipse.jdt.annotation.NonNull;


	public class Trace {

	/**
	* String containing an open parenthesis.
	*
	*/
	protected static final String PARENTHESIS_OPEN = "("; //$NON-NLS-1$

	/**
	* String containing a close parenthesis.
	*
	*/
	protected static final String PARENTHESIS_CLOSE = ")"; //$NON-NLS-1$

	/**
	* Prefix for tracing the changing of values.
	*
	*/
	protected static final String PREFIX_CHANGING = "CHANGING "; //$NON-NLS-1$

	/**
	* Prefix for tracing the catching of throwables.
	*
	*/
	protected static final String PREFIX_CATCHING = "CAUGHT "; //$NON-NLS-1$

	/**
	* Prefix for tracing the throwing of throwables.
	*
	*/
	protected static final String PREFIX_THROWING = "THROWN "; //$NON-NLS-1$

	/**
	* Prefix for tracing the entering of methods.
	*
	*/
	protected static final String PREFIX_ENTERING = "ENTERING "; //$NON-NLS-1$

	/**
	* Prefix for tracing the exiting of methods.
	*
	*/
	protected static final String PREFIX_EXITING = "EXITING "; //$NON-NLS-1$

	/**
	* Separator for methods.
	*
	*/
	protected static final String SEPARATOR_METHOD = "#"; //$NON-NLS-1$

	/**
	* Separator for parameters.
	*
	*/
	protected static final String SEPARATOR_PARAMETER = ", "; //$NON-NLS-1$

	/**
	* Separator for return values.
	*
	*/
	protected static final String SEPARATOR_RETURN = ":"; //$NON-NLS-1$

	/**
	* Separator containing a space.
	*
	*/
	protected static final String SEPARATOR_SPACE = " "; //$NON-NLS-1$

	/**
	* Label indicating old value.
	*
	*/
	protected static final String LABEL_OLD_VALUE = "old="; //$NON-NLS-1$

	/**
	* Label indicating new value.
	*
	*/
	protected static final String LABEL_NEW_VALUE = "new="; //$NON-NLS-1$

	protected final @NonNull String exceptionsCatchingOption;
	protected final @NonNull String exceptionsThrowingOption;
	protected final @NonNull String methodsEnteringOption;
	protected final @NonNull String methodsExitingOption;
	private Tracing fTracing;


	public Trace(@NonNull String exceptionsCatchingOption, @NonNull String exceptionsThrowingOption,
	@NonNull String methodsEnteringOption, @NonNull String methodsExitingOption) {
	this.exceptionsCatchingOption = exceptionsCatchingOption;
	this.exceptionsThrowingOption = exceptionsThrowingOption;
	this.methodsEnteringOption = methodsEnteringOption;
	this.methodsExitingOption = methodsExitingOption;
	fTracing = new Tracing();
	}

	protected void start(Plugin plugin) {
	fTracing.start(plugin);
	}

	protected void stop() {
	fTracing.stop();
	}

	/**
	* Queries whether method entry tracing is enabled.
	*
	* @return whether method entry tracing is enabled
	*/
	public boolean shouldTraceEntering() {
	return shouldTrace(methodsEnteringOption);
	}

	/**
	* Queries whether method entry tracing is enabled for the specified
	* debug option.
	*
	* @param option the debug option to test
	* @return whether method entry tracing is enabled for the option
	*/
	public boolean shouldTraceEntering(String option) {
	return shouldTraceEntering() && shouldTrace(option);
	}

	/**
	* Queries whether method exit tracing is enabled.
	*
	* @return whether method exit tracing is enabled
	*/
	public boolean shouldTraceExiting() {
	return fTracing.shouldTrace(methodsExitingOption);
	}

	/**
	* Queries whether method exit tracing is enabled for the specified
	* debug option.
	*
	* @param option the debug option to test
	* @return whether method exit tracing is enabled for the option
	*/
	public boolean shouldTraceExiting(String option) {
	return shouldTraceExiting() && fTracing.shouldTrace(option);
	}

	/**
	* Queries whether exception catch tracing is enabled.
	*
	* @return whether exception catch tracing is enabled
	*/
	public boolean shouldTraceCatching() {
	return fTracing.shouldTrace(exceptionsCatchingOption);
	}

	/**
	* Queries whether exception throw tracing is enabled.
	*
	* @return whether exception throw tracing is enabled
	*/
	public boolean shouldTraceThrowing() {
	return fTracing.shouldTrace(exceptionsThrowingOption);
	}

	/**
	* Queries whether tracing is enabled for the
	* specified debug option of this plug-in.
	*
	* @param option The debug option for which to determine trace enablement.
	* @return Whether tracing is enabled for the debug option of the plug-in.
	*/
	public boolean shouldTrace(String option) {
	return fTracing.shouldTrace(
	option);
	}

	/**
	* Traces the specified message from this plug-in.
	*
	* @param message The message to be traced.
	*/
	public void trace(String message) {
	fTracing.trace(message);
	}

	/**
	* Traces the specified message from this plug-in for the specified
	* debug option.
	*
	* @param option The debug option for which to trace.
	* @param message The message to be traced.
	*/
	public void trace(String option, String message) {
	fTracing.trace(
	option,
	message);
	}

	/**
	* Traces an entry into the specified method of the specified class.
	*
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	*/
	public void entering(
	Class<?> clazz,
	String methodName) {

	fTracing.entering(
	methodsEnteringOption,
	clazz,
	methodName);
	}

	/**
	* Traces an entry into the specified method of the specified class,
	* with the specified parameter.
	*
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	* @param parameter The parameter to the method being entered.
	*/
	public void entering(
	Class<?> clazz,
	String methodName,
	Object parameter) {

	fTracing.entering(
	methodsEnteringOption,
	clazz,
	methodName,
	parameter);
	}

	/**
	* Traces an entry into the specified method of the specified class,
	* with the specified parameters.
	*
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	* @param parameters The parameters to the method being entered.
	*/
	public void entering(
	Class<?> clazz,
	String methodName,
	Object[] parameters) {

	fTracing.entering(
	methodsEnteringOption,
	clazz,
	methodName,
	parameters);
	}

	/**
	* Traces an entry into the specified method of the specified class.
	*
	* @param option only trace entering if this option is enabled (in addition
	* to the generic method-entry option)
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	*/
	public void entering(
	String option,
	Class<?> clazz,
	String methodName) {

	if (shouldTraceEntering()) {
	fTracing.entering(
	option,
	clazz,
	methodName);
	}
	}

	/**
	* Traces an entry into the specified method of the specified class,
	* with the specified parameter.
	*
	* @param option only trace entering if this option is enabled (in addition
	* to the generic method-entry option)
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	* @param parameter The parameter to the method being entered.
	*/
	public void entering(
	String option,
	Class<?> clazz,
	String methodName,
	Object parameter) {

	if (shouldTraceEntering()) {
	fTracing.entering(
	option,
	clazz,
	methodName,
	parameter);
	}
	}

	/**
	* Traces an entry into the specified method of the specified class,
	* with the specified parameters.
	*
	* @param option only trace entering if this option is enabled (in addition
	* to the generic method-entry option)
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	* @param parameters The parameters to the method being entered.
	*/
	public void entering(
	String option,
	Class<?> clazz,
	String methodName,
	Object[] parameters) {

	if (shouldTraceEntering()) {
	fTracing.entering(
	option,
	clazz,
	methodName,
	parameters);
	}
	}

	/**
	* Traces an exit from the specified method of the specified class.
	*
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	*/
	public void exiting(
	Class<?> clazz,
	String methodName) {

	fTracing.exiting(
	methodsExitingOption,
	clazz,
	methodName);
	}

	/**
	* Traces an exit from the specified method of the specified class,
	* with the specified return value.
	*
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	* @param returnValue The return value of the method being exited.
	*/
	public void exiting(
	Class<?> clazz,
	String methodName,
	Object returnValue) {

	fTracing.exiting(
	methodsExitingOption,
	clazz,
	methodName,
	returnValue);
	}

	/**
	* Traces an exit from the specified method of the specified class.
	*
	* @param option only trace entering if this option is enabled (in addition
	* to the generic method-exit option)
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	*/
	public void exiting(
	String option,
	Class<?> clazz,
	String methodName) {

	if (shouldTraceExiting()) {
	fTracing.exiting(
	option,
	clazz,
	methodName);
	}
	}

	/**
	* Traces an exit from the specified method of the specified class,
	* with the specified return value.
	*
	* @param option only trace entering if this option is enabled (in addition
	* to the generic method-exit option)
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	* @param returnValue The return value of the method being exited.
	*/
	public void exiting(
	String option,
	Class<?> clazz,
	String methodName,
	Object returnValue) {

	if (shouldTraceExiting()) {
	fTracing.exiting(
	option,
	clazz,
	methodName,
	returnValue);
	}
	}

	/**
	* Traces the catching of the specified throwable in the specified method of
	* the specified class.
	*
	* @param clazz The class in which the throwable is being caught.
	* @param methodName The name of the method in which the throwable is being
	* caught.
	* @param throwable The throwable that is being caught.
	*/
	public void catching(
	Class<?> clazz,
	String methodName,
	Throwable throwable) {

	fTracing.catching(
	exceptionsCatchingOption,
	clazz,
	methodName,
	throwable);
	}

	/**
	* Traces the throwing of the specified throwable from the specified method
	* of the specified class.
	*
	* @param clazz The class from which the throwable is being thrown.
	* @param methodName The name of the method from which the throwable is
	* being thrown.
	* @param throwable The throwable that is being thrown.
	*/
	public void throwing(
	Class<?> clazz,
	String methodName,
	Throwable throwable) {

	fTracing.throwing(
	exceptionsThrowingOption,
	clazz,
	methodName,
	throwable);
	}

	/**
	* Converts an array of objects to a string for trace output.
	*
	* @param array the array to convert to a string
	* @return the string
	*/
	public static String toString(Object[] array) {
	StringBuffer result = new StringBuffer(64);

	result.append('[');

	for (int i = 0; i < array.length; i++) {
	if (i > 0) {
	result.append(", "); //$NON-NLS-1$
	}

	result.append(array[i]);
	}

	result.append(']');

	return result.toString();
	}


	private class Tracing {

	private Plugin fPlugin;

	Tracing() {
	super();
	}

	synchronized void start(Plugin plugin) {
	fPlugin = plugin;
	}

	synchronized void stop() {
	fPlugin = null;
	}

	/**
	* The cached debug options (for optimization).
	*/
	private final Map<String, Boolean> cachedOptions = new HashMap<String, Boolean>();

	/**
	* Retrieves a Boolean value indicating whether tracing is enabled.
	*
	* @return Whether tracing is enabled for the plug-in.
	*
	*/
	protected synchronized boolean shouldTrace() {
	return fPlugin != null && fPlugin.isDebugging();
	}

	/**
	* Retrieves a Boolean value indicating whether tracing is enabled for the
	* specified debug option.
	*
	* @return Whether tracing is enabled for the debug option of the plug-in.
	* @param option The debug option for which to determine trace enablement.
	*
	*/
	public boolean shouldTrace(String option) {
	if (shouldTrace()) {
	Boolean value = null;

	synchronized (cachedOptions) {
	value = cachedOptions.get(option);

	if (null == value) {
	value =
	Boolean.valueOf(
	org.eclipse.core.runtime.Platform.getDebugOption(option));

	cachedOptions.put(option, value);
	}
	}

	return value.booleanValue();
	}

	return false;
	}

	/**
	* Retrieves a textual representation of the specified argument.
	*
	* @return A textual representation of the specified argument.
	* @param argument The argument for which to retrieve a textual
	* representation.
	*
	*/
	protected String getArgumentString(Object argument) {
	return String.valueOf(argument);
	}

	/**
	* Retrieves a textual representation of the specified arguments.
	*
	* @return A textual representation of the specified arguments.
	* @param arguments The arguments for which to retrieve a textual
	* representation.
	*
	*/
	protected String getArgumentsString(Object[] arguments) {
	StringBuffer buffer = new StringBuffer();

	for (int i = 0; i < arguments.length; i++) {
	buffer.append(getArgumentString(arguments[i]));

	if (i < arguments.length - 1) {
	buffer.append(SEPARATOR_PARAMETER);
	}
	}

	return buffer.toString();
	}

	/**
	* Traces the specified message.
	*
	* @param message The message to be traced.
	*
	*/
	public void trace(String message) {
	if (shouldTrace()) {
	System.out.println(message);
	}
	}

	/**
	* Traces the specified message for the specified
	* debug option.
	*
	* @param option The debug option for which to trace.
	* @param message The message to be traced.
	*
	*/
	public void trace(String option, String message) {
	if (shouldTrace(option)) {
	trace(message);
	}
	}

	/**
	* Traces the catching of the specified throwable in the specified method of
	* the specified class.
	*
	* @param option The debug option for which to trace.
	* @param clazz The class in which the throwable is being caught.
	* @param methodName The name of the method in which the throwable is being
	* caught.
	* @param throwable The throwable that is being caught.
	*
	*/
	public void catching(
	String option,
	Class<?> clazz,
	String methodName,
	Throwable throwable) {

	if (shouldTrace(option)) {

	trace(
	PREFIX_CATCHING
	+ throwable.getMessage()
	+ SEPARATOR_SPACE
	+ PARENTHESIS_OPEN
	+ clazz.getName()
	+ SEPARATOR_METHOD
	+ methodName
	+ PARENTHESIS_CLOSE);

	throwable.printStackTrace(System.err);
	}
	}

	/**
	* Traces the throwing of the specified throwable from the specified method
	* of the specified class.
	*
	* @param option The debug option for which to trace.
	* @param clazz The class from which the throwable is being thrown.
	* @param methodName The name of the method from which the throwable is
	* being thrown.
	* @param throwable The throwable that is being thrown.
	*
	*/
	public void throwing(
	String option,
	Class<?> clazz,
	String methodName,
	Throwable throwable) {

	if (shouldTrace(option)) {

	trace(
	PREFIX_THROWING
	+ throwable.getMessage()
	+ SEPARATOR_SPACE
	+ PARENTHESIS_OPEN
	+ clazz.getName()
	+ SEPARATOR_METHOD
	+ methodName
	+ PARENTHESIS_CLOSE);

	throwable.printStackTrace(System.err);
	}
	}

	/**
	* Traces the entering into the specified method of the specified class,
	* with the specified parameters.
	*
	* @param option The debug option for which to trace.
	* @param clazz The class whose method is being entered.
	* @param methodName The name of method that is being entered.
	* @param parameters The parameters to the method being entered.
	*
	*/
	public void entering(
	String option,
	Class<?> clazz,
	String methodName,
	Object... parameters) {

	if (shouldTrace(option)) {

	trace(
	PREFIX_ENTERING
	+ clazz.getName()
	+ SEPARATOR_METHOD
	+ methodName
	+ PARENTHESIS_OPEN
	+ getArgumentsString(parameters)
	+ PARENTHESIS_CLOSE);
	}
	}

	/**
	* Traces the exiting from the specified method of the specified class.
	*
	* @param option The debug option for which to trace.
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	*
	*/
	public void exiting(
	String option,
	Class<?> clazz,
	String methodName) {

	if (shouldTrace(option)) {

	trace(
	PREFIX_EXITING
	+ clazz.getName()
	+ SEPARATOR_METHOD
	+ methodName);
	}
	}

	/**
	* Traces the exiting from the specified method of the specified class,
	* with the specified return value.
	*
	* @param option The debug option for which to trace.
	* @param clazz The class whose method is being exited.
	* @param methodName The name of method that is being exited.
	* @param returnValue The return value of the method being exited.
	*
	*/
	public void exiting(
	String option,
	Class<?> clazz,
	String methodName,
	Object returnValue) {

	if (shouldTrace(option)) {

	trace(
	PREFIX_EXITING
	+ clazz.getName()
	+ SEPARATOR_METHOD
	+ methodName
	+ SEPARATOR_RETURN
	+ getArgumentString(returnValue));
	}
	}
	}

	}