01: /*
02: * Licensed to the Apache Software Foundation (ASF) under one or more
03: * contributor license agreements. See the NOTICE file distributed with
04: * this work for additional information regarding copyright ownership.
05: * The ASF licenses this file to You under the Apache License, Version 2.0
06: * (the "License"); you may not use this file except in compliance with
07: * the License. You may obtain a copy of the License at
08: *
09: * http://www.apache.org/licenses/LICENSE-2.0
10: *
11: * Unless required by applicable law or agreed to in writing, software
12: * distributed under the License is distributed on an "AS IS" BASIS,
13: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14: * See the License for the specific language governing permissions and
15: * limitations under the License.
16: */
17:
18: package org.apache.harmony.misc.accessors;
19:
20: /**
21: * Provides access to call stack trace.
22: */
23: public class ThreadStackAccessor {
24: private static ThreadStackAccessor instance;
25:
26: static ThreadStackAccessor getInstance() {
27: if (instance == null) {
28: instance = new ThreadStackAccessor();
29: }
30: return instance;
31: }
32:
33: /** VM independent implementation of getCallerClasses */
34: private class ClassContext extends SecurityManager {
35: public Class[] getCallerClass() {
36: return getClassContext();
37: }
38: }
39:
40: private ClassContext classContext = new ClassContext();
41:
42: private ThreadStackAccessor() {
43: }
44:
45: /**
46: * Returns the class from the specified depth in the stack. If the
47: * specified depth is equal to zero then the caller of the caller of this
48: * method should be returned. Reflection stack frames should not be taken
49: * into account.
50: *
51: * @param depth the stack depth to get a caller class from. It is not
52: * negative one.
53: * @return class a class from the stack. If there is no class in specified
54: * depth, null is returned.
55: */
56: public Class getCallerClass(int depth) {
57: return getClasses(depth + 1, true)[depth];
58: }
59:
60: /**
61: * Collects and returns the stack of invoked methods as an array of the
62: * {@link StackTraceElement} objects. This method may be used by security
63: * checks implementation. It is not supposed to be used by Throwable class.
64: * <p>
65: * Note, that this method itself is excluded from the returned stack trace.
66: * The most top (recently invoked) method is stored as a first element of the array.
67: *
68: * @return a stack of invoked methods as an array.
69: */
70: public StackTraceElement[] getCallsTrace() {
71: return (new Throwable()).getStackTrace();
72: }
73:
74: /**
75: * Collects and returns the stack of the current thread as an array of
76: * classes. Resulting array should contain maxSize elements at the maximum.
77: * Note that reflection stack frames should not be taken into account. The
78: * caller of the caller of this method is stored as a first element of the
79: * array. If considerPrivileged is true then the last element of the array
80: * should be the caller of the most recent privileged method.
81: * <p>
82: * This method may be used by security checks implementation. It is not
83: * supposed to be used by Throwable class.
84: *
85: * @param maxSize maximum size of resulting array. If maxSize is less than
86: * zero array may contain any number of elements.
87: * @param considerPrivileged indicates that privileged methods should be
88: * taken into account. It means if considerPrivileged is true the
89: * last element of resulting array should be the caller of the most
90: * recent privileged method. If considerPrivileged is false then
91: * privileged methods don't affect resulting array.
92: *
93: * @return a stack of invoked methods as an array of classes.
94: */
95: public Class[] getClasses(int maxSize, boolean considerPrivileged) {
96: return classContext.getCallerClass();
97: }
98: }
|