Gets the calling method's name.

@return the calling method's name.
978236
public static String getCaller() {
		StackTraceElement[] stes = new Exception().getStackTrace();
		String caller;

		if (stes.length > 2) {
			StackTraceElement callerSte = stes[2];

			caller = callerSte.getClassName() + "." + callerSte.getMethodName();
		} else {
			caller = "<unknown>";
		}
		return caller;
	}
757105
public String getName(Method method) {
        String name = getMethodName(method);

        if (method.isAnnotationPresent(JsonProperty.class) &&
            !"".equals(method.getAnnotation(JsonProperty.class).value())) {
            name = method.getAnnotation(JsonProperty.class).value();
        } else if (serializationConfig != null && serializationConfig.getPropertyNamingStrategy() != null) {
            Annotation[] declaredAnnotations = method.getDeclaredAnnotations();
            AnnotationMap annotationMap = buildAnnotationMap(declaredAnnotations);

            int paramsLength = method.getParameterAnnotations().length;
            AnnotationMap[] paramAnnotations = new AnnotationMap[paramsLength];
            for (int i = 0; i < paramsLength; i++) {
                AnnotationMap parameterAnnotationMap = buildAnnotationMap(method.getParameterAnnotations()[i]);
                paramAnnotations[i] = parameterAnnotationMap;
            }

            AnnotatedClass annotatedClass = AnnotatedClassBuilder.build(method.getDeclaringClass(), serializationConfig);
            AnnotatedMethod annotatedField = AnnotatedMethodBuilder.build(annotatedClass, method, annotationMap, paramAnnotations);
            name = serializationConfig.getPropertyNamingStrategy().nameForGetterMethod(serializationConfig, annotatedField, name);
        }
        return name;
    }
1261677
protected static function _getCallingMethod()
    {
        $_backTrace = debug_backtrace();

        $_thisClass = get_called_class();
        $_type = $_class = $_method = null;

        for ( $_i = 0, $_size = sizeof( $_backTrace ); $_i < $_size; $_i++ )
        {
            if ( isset( $_backTrace[$_i]['class'] ) )
            {
                $_class = $_backTrace[$_i]['class'];
            }

            if ( $_class == $_thisClass )
            {
                continue;
            }

            if ( isset( $_backTrace[$_i]['method'] ) )
            {
                $_method = $_backTrace[$_i]['method'];
            }
            else if ( isset( $_backTrace[$_i]['function'] ) )
            {
                $_method = $_backTrace[$_i]['function'];
            }
            else
            {
                $_method = 'Unknown';
            }

            $_type = $_backTrace[$_i]['type'];
            break;
        }

        if ( $_i >= 0 )
        {
            return str_ireplace( 'Kisma\\Core\\', 'Core\\', $_class ) . $_type . $_method;
        }

        return 'Unknown';
    }
914364
@Override
    public String getMethodName()
    {
        // Generally, the method name is pretty static, but for internal
        // CMR methods (with index < 0) they are dynamic, and based on
        // the signature. For performance, the substring operation is
        // deferred until the method name is actually used.             d154342.10
        if (methodName == null && methodSignature != null)
            methodName = methodSignature.substring(0, methodSignature.indexOf(":"));

        return methodName;
    }
885437
public HttpMethod getRequestMethod() {
        final Object method = getHeader(HttpMessageHeaders.HTTP_REQUEST_METHOD);

        if (method != null) {
            return HttpMethod.valueOf(method.toString());
        }

        return null;
    }
1355207
public static String getPropertyName(Method method) {
        String methodName = method.getName();
        final String get = "get";
        final String is = "is";
        if (methodName.startsWith(get)) {
            return decapitalize(methodName.substring(get.length()));
        } else if (methodName.startsWith(is)) {
            return decapitalize(methodName.substring(is.length()));
        } else {
            return null;
        }

    }
799908
protected String extractPropertyName(Method method) {
		String name = method.getName();
		name = name.startsWith("is") ? name.substring(NUM_2) : name.substring(NUM_3);
		return name;
	}
805028
public String getClassName() {
        switch (sort) {
        case VOID:
            return "void";
        case BOOLEAN:
            return "boolean";
        case CHAR:
            return "char";
        case BYTE:
            return "byte";
        case SHORT:
            return "short";
        case INT:
            return "int";
        case FLOAT:
            return "float";
        case LONG:
            return "long";
        case DOUBLE:
            return "double";
        case ARRAY:
            StringBuilder sb = new StringBuilder(getElementType().getClassName());
            for (int i = getDimensions(); i > 0; --i) {
                sb.append("[]");
            }
            return sb.toString();
        case OBJECT:
            return new String(buf, off, len).replace('/', '.').intern();
        default:
            return null;
        }
    }
75220
public static String getName(final Method m) {
		StringBuilder ret = new StringBuilder();
		ret.append(getName(m.getReturnType())).append(' ');
		ret.append(m.getName()).append('(');
		Class<?>[] parameterTypes = m.getParameterTypes();
		for (int i = 0; i < parameterTypes.length; i++) {
			if (i > 0)
				ret.append(',');
			ret.append(getName(parameterTypes[i]));
		}
		ret.append(')');
		return ret.toString();
	}
1287992
@Override
    public String getMethod() {
        String method = this.request.getMethod();
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getMethod: " + method);
        }
        return method;
    }
719396
public static function GetCallingStepName()
    {
        $sCallingStepName = null;
        if (array_key_exists(self::SESSION_KEY_NAME, $_SESSION)) {
            $sCallingStepName = $_SESSION[self::SESSION_KEY_NAME];
        }

        return $sCallingStepName;
    }
401328
public static String getCaller() {
		Exception e = new Exception();
		StackTraceElement[] stack = e.getStackTrace();
		if (stack == null || stack.length < 2) return "?";
		// 0 is here, 1 is the caller of this method, 2 is its caller
		return stack[2].getClassName() + "#" + stack[2].getMethodName() + ":" + stack[2].getLineNumber();
	}
484705
public final String getName() {
        final String methodName = "getName";
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled()) {
            trace.entry(this, cclass, methodName);
            trace.exit(this, cclass, methodName, new Object[] { storeName });
        }
        return storeName;
    }
758104
public function getName()
    {
        if ($this->name === null) {
            $class = get_called_class();
            if (preg_match('/_+(.+)_+/', $class, $matches) > 0) {
                $this->name = $matches[1];
            } else {
                $this->name = '';
            }
        }

        return $this->name;
    }
255482
public static String getMainClassName() {
		StackTraceElement trace[] = Thread.currentThread().getStackTrace();
		if (trace.length > 0) {
			return trace[trace.length - 1].getClassName();
		}
		return "Unknown";
	}
1137526
public static String getCallerMethod() {
		StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
		if (stacktrace.length >= 4) {
			StackTraceElement element = stacktrace[3];
			return element.getClassName() + '.' + element.getMethodName() + "()";
		} else {
			return StringUtils.EMPTY;
		}
	}
919788
public String getName()
    {
        if (_name==null)
        {
            _name=this.getClass().getName();
            if (!log.isDebugEnabled())
                _name=_name.substring(_name.lastIndexOf('.')+1);
        }
        return _name;
    }