java.lang.Throwable.nativeFillInStackTrace java code examples

Common ways to obtain Throwable

private void myMethod () {
 Throwable t =InvocationTargetException e;e.getTargetException()
InvocationTargetException e;e.getCause()
Exception e;e.getCause()
Smart code suggestions by Tabnine
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

/**
 * Records the stack trace from the point where this method has been called
 * to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.
 *
 * <p>This method is public so that code (such as an RPC system) which catches
 * a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 * with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 * {@code fillInStackTrace}.
 *
 * <p>This method is non-final so that non-Java language implementations can disable VM stack
 * traces for their language. Filling in the stack trace is relatively expensive.
 * <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 * language to avoid paying for something it doesn't need.
 *
 * @return this {@code Throwable} instance.
 */
public Throwable fillInStackTrace() {
  if (stackTrace == null) {
    return this; // writableStackTrace was false.
  }
  // Fill in the intermediate representation.
  stackState = nativeFillInStackTrace();
  // Mark the full representation as in need of update.
  stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
  return this;
}

Popular methods of Throwable

getMessage
Returns the detail message string of this throwable.
printStackTrace
getCause
Returns the cause of this throwable or null if the cause is nonexistent or unknown. (The cause is th
toString
Returns a short description of this throwable. The result is the concatenation of: * the Class#getN
getStackTrace
Provides programmatic access to the stack trace information printed by #printStackTrace(). Returns a
<init>
Constructs a new throwable with the specified cause and a detail message of (cause==null ? null : ca
getLocalizedMessage
Creates a localized description of this throwable. Subclasses may override this method in order to p
setStackTrace
Sets the stack trace elements that will be returned by #getStackTrace() and printed by #printStackTr
addSuppressed
Appends the specified exception to the exceptions that were suppressed in order to deliver this exce
initCause
Initializes the cause of this throwable to the specified value. (The cause is the throwable that cau
fillInStackTrace
getSuppressed
Returns the throwables suppressed by this.

Popular in Java

Start an intent from android
runOnUiThread (Activity)
setContentView (Activity)
notifyDataSetChanged (ArrayAdapter)
Component (java.awt)
A component is an object having a graphical representation that can be displayed on the screen and t
Set (java.util)
A Set is a data structure which does not allow duplicate elements.
HttpServletRequest (javax.servlet.http)
Extends the javax.servlet.ServletRequest interface to provide request information for HTTP servlets.
JOptionPane (javax.swing)
Join (org.hibernate.mapping)
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin
Top 17 Plugins for Android Studio

How to use nativeFillInStackTracemethodin java.lang.Throwable

Best Java code snippets using java.lang.Throwable.nativeFillInStackTrace (Showing top 7 results out of 315)

How to use
nativeFillInStackTrace
method
in
java.lang.Throwable