コード例 #1
0
 protected void _addMethodMixIns(
     MethodFilter methodFilter,
     AnnotatedMethodMap methods,
     Class<?> mixInCls,
     AnnotatedMethodMap mixIns) {
   for (Method m : mixInCls.getDeclaredMethods()) {
     if (!_isIncludableMethod(m, methodFilter)) {
       continue;
     }
     AnnotatedMethod am = methods.find(m);
     /* Do we already have a method to augment (from sub-class
      * that will mask this mixIn)? If so, add if visible
      * without masking (no such annotation)
      */
     if (am != null) {
       _addMixUnders(m, am);
       /* Otherwise will have precedence, but must wait
        * until we find the real method (mixIn methods are
        * just placeholder, can't be called)
        */
     } else {
       mixIns.add(_constructMethod(m));
     }
   }
 }
コード例 #2
0
  protected void _addMemberMethods(
      Class<?> cls,
      MethodFilter methodFilter,
      AnnotatedMethodMap methods,
      Class<?> mixInCls,
      AnnotatedMethodMap mixIns) {
    // first, mixIns, since they have higher priority then class methods
    if (mixInCls != null) {
      _addMethodMixIns(methodFilter, methods, mixInCls, mixIns);
    }

    if (cls == null) { // just so caller need not check when passing super-class
      return;
    }
    // then methods from the class itself
    for (Method m : cls.getDeclaredMethods()) {
      if (!_isIncludableMethod(m, methodFilter)) {
        continue;
      }
      AnnotatedMethod old = methods.find(m);
      if (old == null) {
        AnnotatedMethod newM = _constructMethod(m);
        methods.add(newM);
        // Ok, but is there a mix-in to connect now?
        old = mixIns.remove(m);
        if (old != null) {
          _addMixOvers(old.getAnnotated(), newM, false);
        }
      } else {
        /* If sub-class already has the method, we only want to augment
         * annotations with entries that are not masked by sub-class.
         */
        _addMixUnders(m, old);

        /* 06-Jan-2010, tatu: [JACKSON-450] Except that if method we saw first is
         *   from an interface, and we now find a non-interface definition, we should
         *   use this method, but with combination of annotations.
         *   This helps (or rather, is essential) with JAXB annotations and
         *   may also result in faster method calls (interface calls are slightly
         *   costlier than regular method calls)
         */
        if (old.getDeclaringClass().isInterface() && !m.getDeclaringClass().isInterface()) {
          methods.add(old.withMethod(m));
        }
      }
    }
  }
コード例 #3
0
 public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes) {
   return _memberMethods.find(name, paramTypes);
 }