All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.sun.xml.messaging.saaj.SOAPExceptionImpl Maven / Gradle / Ivy

There is a newer version: 4.0.3
Show newest version
/*
 * Copyright (c) 1997, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0, which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package com.sun.xml.messaging.saaj;

import java.io.PrintStream;
import java.io.PrintWriter;

import jakarta.xml.soap.SOAPException;

/**
 * An exception that signals that a SOAP exception has occurred. A
 * SOAPExceptionImpl object may contain a String
 * that gives the reason for the exception, an embedded
 * Throwable object, or both. This class provides methods
 * for retrieving reason messages and for retrieving the embedded
 * Throwable object.
 *
 * 

Typical reasons for throwing a SOAPExceptionImpl * object are problems such as difficulty setting a header, not being * able to send a message, and not being able to get a connection with * the provider. Reasons for embedding a Throwable * object include problems such as input/output errors or a parsing * problem, such as an error in parsing a header. */ public class SOAPExceptionImpl extends SOAPException { private Throwable cause; /** * Constructs a SOAPExceptionImpl object with no * reason or embedded Throwable object. */ public SOAPExceptionImpl() { super(); this.cause = null; } /** * Constructs a SOAPExceptionImpl object with the given * String as the reason for the exception being thrown. * * @param reason a description of what caused the exception */ public SOAPExceptionImpl(String reason) { super(reason); this.cause = null; } /** * Constructs a SOAPExceptionImpl object with the given * String as the reason for the exception being thrown * and the given Throwable object as an embedded * exception. * * @param reason a description of what caused the exception * @param cause a Throwable object that is to * be embedded in this SOAPExceptionImpl object */ public SOAPExceptionImpl(String reason, Throwable cause) { super (reason); initCause(cause); } /** * Constructs a SOAPExceptionImpl object initialized * with the given Throwable object. * @param cause cause */ public SOAPExceptionImpl(Throwable cause) { super (cause.toString()); initCause(cause); } /** * Returns the detail message for this SOAPExceptionImpl * object. *

* If there is an embedded Throwable object, and if the * SOAPExceptionImpl object has no detail message of its * own, this method will return the detail message from the embedded * Throwable object. * * @return the error or warning message for this * SOAPExceptionImpl or, if it has none, the * message of the embedded Throwable object, * if there is one */ @Override public String getMessage() { String message = super.getMessage (); if (message == null && cause != null) { return cause.getMessage(); } else { return message; } } /** * Returns the Throwable object embedded in this * SOAPExceptionImpl if there is one. Otherwise, this method * returns null. * * @return the embedded Throwable object or null * if there is none */ @Override public Throwable getCause() { return cause; } /** * Initializes the cause field of this SOAPExceptionImpl * object with the given Throwable object. *

* This method can be called at most once. It is generally called from * within the constructor or immediately after the constructor has * returned a new SOAPExceptionImpl object. * If this SOAPExceptionImpl object was created with the * constructor {@link #SOAPExceptionImpl(Throwable)} or * {@link #SOAPExceptionImpl(String,Throwable)}, meaning that its * cause field already has a value, this method cannot be * called even once. * * @param cause the Throwable object that caused this * SOAPExceptionImpl object to be thrown. The value of this * parameter is saved for later retrieval by the * {@link #getCause()} method. A {@code null} value is * permitted and indicates that the cause is nonexistent or * unknown. * @return a reference to this SOAPExceptionImpl instance * @throws IllegalArgumentException if cause is this * Throwable object. (A Throwable object * cannot be its own cause.) * @throws IllegalStateException if this SOAPExceptionImpl object * was created with {@link #SOAPExceptionImpl(Throwable)} or * {@link #SOAPExceptionImpl(String,Throwable)}, or this * method has already been called on this SOAPExceptionImpl * object */ @Override public synchronized Throwable initCause(Throwable cause) { if(this.cause != null) { throw new IllegalStateException("Can't override cause"); } if(cause == this) { throw new IllegalArgumentException("Self-causation not permitted"); } this.cause = cause; return this; } @Override public void printStackTrace() { super.printStackTrace(); if (cause != null) { System.err.println("\nCAUSE:\n"); cause.printStackTrace(); } } @Override public void printStackTrace(PrintStream s) { super.printStackTrace(s); if (cause != null) { s.println("\nCAUSE:\n"); cause.printStackTrace(s); } } @Override public void printStackTrace(PrintWriter s) { super.printStackTrace(s); if (cause != null) { s.println("\nCAUSE:\n"); cause.printStackTrace(s); } } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy