@PerformanceSensitive public static Class<?> getCallerClass(final int depth) { return stackLocator.getCallerClass(depth + 1); }
public static StackTraceElement calcLocation(final String fqcnOfLogger) { return stackLocator.calcLocation(fqcnOfLogger); } }
@PerformanceSensitive public static Stack<Class<?>> getCurrentStackTrace() { return stackLocator.getCurrentStackTrace(); }
/** * Returns a Logger with the name of the calling class. * * @return The Logger for the calling class. */ public static Logger getLogger() { String name = StackLocator.getInstance().getCallerClass(2).getName(); return new FastLogger( LogManager.getLogger(name, GemFireParameterizedMessageFactory.INSTANCE)); }
@PerformanceSensitive public Stack<Class<?>> getCurrentStackTrace() { // benchmarks show that using the SecurityManager is much faster than looping through getCallerClass(int) if (getSecurityManager() != null) { final Class<?>[] array = getSecurityManager().getClassContext(); final Stack<Class<?>> classes = new Stack<>(); classes.ensureCapacity(array.length); for (final Class<?> clazz : array) { classes.push(clazz); } return classes; } // slower version using getCallerClass where we cannot use a SecurityManager final Stack<Class<?>> classes = new Stack<>(); Class<?> clazz; for (int i = 1; null != (clazz = getCallerClass(i)); i++) { classes.push(clazz); } return classes; }
public static StackTraceElement getStackTraceElement(final int depth) { return stackLocator.getStackTraceElement(depth + 1); } // migrated from ClassLoaderContextSelector
public StackTraceElement getStackTraceElement(final int depth) { // (MS) I tested the difference between using Throwable.getStackTrace() and Thread.getStackTrace(), and // the version using Throwable was surprisingly faster! at least on Java 1.8. See ReflectionBenchmark. final StackTraceElement[] elements = new Throwable().getStackTrace(); int i = 0; for (final StackTraceElement element : elements) { if (isValid(element)) { if (i == depth) { return element; } ++i; } } throw new IndexOutOfBoundsException(Integer.toString(depth)); }
@PerformanceSensitive public Stack<Class<?>> getCurrentStackTrace() { // benchmarks show that using the SecurityManager is much faster than looping through getCallerClass(int) if (getSecurityManager() != null) { final Class<?>[] array = getSecurityManager().getClassContext(); final Stack<Class<?>> classes = new Stack<>(); classes.ensureCapacity(array.length); for (final Class<?> clazz : array) { classes.push(clazz); } return classes; } // slower version using getCallerClass where we cannot use a SecurityManager final Stack<Class<?>> classes = new Stack<>(); Class<?> clazz; for (int i = 1; null != (clazz = getCallerClass(i)); i++) { classes.push(clazz); } return classes; }
public static StackTraceElement getStackTraceElement(final int depth) { return stackLocator.getStackTraceElement(depth + 1); } // migrated from ClassLoaderContextSelector
public StackTraceElement getStackTraceElement(final int depth) { // (MS) I tested the difference between using Throwable.getStackTrace() and Thread.getStackTrace(), and // the version using Throwable was surprisingly faster! at least on Java 1.8. See ReflectionBenchmark. final StackTraceElement[] elements = new Throwable().getStackTrace(); int i = 0; for (final StackTraceElement element : elements) { if (isValid(element)) { if (i == depth) { return element; } ++i; } } throw new IndexOutOfBoundsException(Integer.toString(depth)); }
@PerformanceSensitive public static Class<?> getCallerClass(final String fqcn, final String pkg) { return stackLocator.getCallerClass(fqcn, pkg); }
public static StackTraceElement calcLocation(final String fqcnOfLogger) { return stackLocator.calcLocation(fqcnOfLogger); } }
@PerformanceSensitive public static Stack<Class<?>> getCurrentStackTrace() { return stackLocator.getCurrentStackTrace(); }
@PerformanceSensitive public static Class<?> getCallerClass(final Class<?> anchor) { return stackLocator.getCallerClass(anchor); }
@PerformanceSensitive public Class<?> getCallerClass(final Class<?> anchor) { boolean next = false; Class<?> clazz; for (int i = 2; null != (clazz = getCallerClass(i)); i++) { if (anchor.equals(clazz)) { next = true; continue; } if (next) { return clazz; } } return Object.class; }
@PerformanceSensitive public Class<?> getCallerClass(final String fqcn, final String pkg) { boolean next = false; Class<?> clazz; for (int i = 2; null != (clazz = getCallerClass(i)); i++) { if (fqcn.equals(clazz.getName())) { next = true; continue; } if (next && clazz.getName().startsWith(pkg)) { return clazz; } } // TODO: return Object.class return null; }
protected Encoder(Builder<? extends Encoder> builder) { logger = LogManager.getLogger(stacklocator.getCallerClass(2)); this.field = builder.field; }
protected Decoder(Builder<? extends Decoder> builder) { logger = LogManager.getLogger(stacklocator.getCallerClass(2)); field = builder.field; }
@PerformanceSensitive public static Class<?> getCallerClass(final Class<?> anchor) { return stackLocator.getCallerClass(anchor); }
@PerformanceSensitive public static Class<?> getCallerClass(final int depth) { return stackLocator.getCallerClass(depth + 1); }