Examples with Pattern org.apache.camel.Pattern used on opensource projects

Example 1 with Pattern

use of org.apache.camel.Pattern in project camel by apache.

the class MethodInfo method findOneWayAnnotation.

/**
     * Finds the oneway annotation in priority order; look for method level annotations first, then the class level annotations,
     * then super class annotations then interface annotations
     *
     * @param method the method on which to search
     * @return the first matching annotation or none if it is not available
     */
protected Pattern findOneWayAnnotation(Method method) {
    Pattern answer = getPatternAnnotation(method);
    if (answer == null) {
        Class<?> type = method.getDeclaringClass();
        // create the search order of types to scan
        List<Class<?>> typesToSearch = new ArrayList<Class<?>>();
        addTypeAndSuperTypes(type, typesToSearch);
        Class<?>[] interfaces = type.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            addTypeAndSuperTypes(anInterface, typesToSearch);
        }
        // now let's scan for a type which the current declared class overloads
        answer = findOneWayAnnotationOnMethod(typesToSearch, method);
        if (answer == null) {
            answer = findOneWayAnnotation(typesToSearch);
        }
    }
    return answer;
}

Example 2 with Pattern

use of org.apache.camel.Pattern in project camel by apache.

the class MethodInfo method getPatternAnnotation.

/**
     * Returns the pattern annotation on the given annotated element; either as a direct annotation or
     * on an annotation which is also annotated
     *
     * @param annotatedElement the element to look for the annotation
     * @param depth the current depth
     * @return the first matching annotation or null if none could be found
     */
protected Pattern getPatternAnnotation(AnnotatedElement annotatedElement, int depth) {
    Pattern answer = annotatedElement.getAnnotation(Pattern.class);
    int nextDepth = depth - 1;
    if (nextDepth > 0) {
        // look at all the annotations to see if any of those are annotated
        Annotation[] annotations = annotatedElement.getAnnotations();
        for (Annotation annotation : annotations) {
            Class<? extends Annotation> annotationType = annotation.annotationType();
            if (annotation instanceof Pattern || annotationType.equals(annotatedElement)) {
                continue;
            } else {
                Pattern another = getPatternAnnotation(annotationType, nextDepth);
                if (pattern != null) {
                    if (answer == null) {
                        answer = another;
                    } else {
                        LOG.warn("Duplicate pattern annotation: " + another + " found on annotation: " + annotation + " which will be ignored");
                    }
                }
            }
        }
    }
    return answer;
}

Example 3 with Pattern

use of org.apache.camel.Pattern in project camel by apache.

the class MethodInfo method findOneWayAnnotationOnMethod.

/**
     * Finds the first annotation on the base methods defined in the list of classes
     */
protected Pattern findOneWayAnnotationOnMethod(List<Class<?>> classes, Method method) {
    for (Class<?> type : classes) {
        try {
            Method definedMethod = type.getMethod(method.getName(), method.getParameterTypes());
            Pattern answer = getPatternAnnotation(definedMethod);
            if (answer != null) {
                return answer;
            }
        } catch (NoSuchMethodException e) {
        // ignore
        }
    }
    return null;
}