java.lang.Throwable.nativeFillInStackTrace java code examples

/**
 * 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

Reactive rest calls using spring rest template
findViewById (Activity)
getSystemService (Context)
scheduleAtFixedRate (Timer)
Menu (java.awt)
ServerSocket (java.net)
This class represents a server-side socket that waits for incoming client connections. A ServerSocke
Charset (java.nio.charset)
A charset is a named mapping between Unicode characters and byte sequences. Every Charset can decode
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
Vector (java.util)
Vector is an implementation of List, backed by an array and synchronized. All optional operations in
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
Best IntelliJ plugins

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