Gives the corresponding statistics for the given target class and AspectJ signature
@param target the target {@link Class}
@param signature the AspectJ signature
@return the related {@link Statistics} or <code>null</code> if it cannot be found
437469
private static Statistics getStatistics(Class<?> target, String signature)
   {
      initIfNeeded();
      Statistics statistics = MAPPING.get(signature);
      if (statistics == null)
      {
         synchronized (JCRAPIAspect.class)
         {
            Class<?> interfaceClass = findInterface(target);
            if (interfaceClass != null)
            {
               Map<String, Statistics> allStatistics = ALL_STATISTICS.get(interfaceClass.getSimpleName());
               if (allStatistics != null)
               {
                  int index1 = signature.indexOf('(');
                  int index = signature.substring(0, index1).lastIndexOf('.');
                  String name = signature.substring(index + 1);
                  statistics = allStatistics.get(name);
               }
            }
            if (statistics == null)
            {
               statistics = UNKNOWN;
            }
            Map<String, Statistics> tempMapping = new HashMap<String, Statistics>(MAPPING);
            tempMapping.put(signature, statistics);
            MAPPING = Collections.unmodifiableMap(tempMapping);            
         }
      }
      if (statistics == UNKNOWN) // NOSONAR
      {
         return null;
      }
      return statistics;
   }
861641
public static String getPattern(Object bean, Object target)
    {
        return stream(bean).filter((s)->{return target.equals(getValue(bean, s));}
288624
public static <T extends Annotation> MethodInvokeProxy proxyByAnnotation(Object target,Class<T> annotationClass,Object ...args)
	{
		Method m=findMethodByAnnotation(target,annotationClass);
		if(m!=null)
		{
			return new MethodInvokeProxy(target, m, args);
		}
		return null;
	}
943513
public static <T> T createProxy(T target, Class<? extends Aspect> aspectClass){
		return createProxy(target, ReflectUtil.newInstance(aspectClass));
	}
344715
@Beta
  public final Predicate<T> equivalentTo(@Nullable T target) {
    return new EquivalentToPredicate<T>(this, target);
  }
585956
public boolean isAssignableTo(Class<?> target) {

        LettuceAssert.notNull(target, "Target type must not be null");

        return LettuceClassUtils.isAssignable(target, getParameterType());
    }
1369561
public static boolean isAnnotationPresent(Class<?> target, Class<? extends Annotation> annotation) {
        Class<?> clazz = target;
        if (clazz.isAnnotationPresent(annotation)) {
            return true;
        }
        while((clazz = clazz.getSuperclass()) != null) {
            if (clazz.isAnnotationPresent(annotation)) {
                return true;
            }
        }
        return false;
    }
251484
public List<Notification> getByTarget(Object target) {
        List<Notification> found = new ArrayList<Notification>();
        for (Notification n: NotificationManager.notifications) {
            for (Object t : ((InteractionNotification)n).getTarget()) {
                if (t.equals(target)){ 
                    logger.fine("...found a match for getByTarget query. With target: "+target);
                    found.add(n);
                }
            }
        }
        if(found.size()>0)        
            return found;
        return null;
    }
116783
public <T> JdbcMapperBuilder<T> newBuilder(final Class<T> target) {
		return newBuilder((Type)target);
	}
322913
public static @CheckForNull
    @SlashedClassName
    String fromFieldSignature(String signature) {
        if (signature.charAt(0) != 'L') {
            return null;
        }
        return signature.substring(1, signature.length() - 1);
    }
619151
public static <T> Predicate<T> equalTo(@Nullable T target) {
		return target == null ? isNull() : t -> Objects.equals(t, target);
	}
1105097
public Integer support(final Class<? extends Throwable> target) {
        return new MinOf(
            new Mapped<>(
                supported -> new InheritanceLevel(target, supported).value(),
                this.exceptions
            )
        ).intValue();
    }
974279
public static BinaryTypeSignature createTypeSignature(String signature) {
//		if (!isSignature(signature)) {
//			throw new IllegalArgumentException(signature);
//		}
		if (signature.charAt(signature.length() - 1) != ';')
			return new BinaryTypeSignature(signature);
		return new BinaryGenericTypeSignature(signature);
	}
1272048
@Override
    public SignatureVisitor visitSuperclass() {
        if (type != CLASS_SIGNATURE || (state & (EMPTY | FORMAL | BOUND)) == 0) {
            throw new IllegalArgumentException();
        }
        state = SUPER;
        SignatureVisitor v = sv == null ? null : sv.visitSuperclass();
        return new CheckSignatureAdapter(TYPE_SIGNATURE, v);
    }
653536
public <T> DynamicJdbcMapper<T> newMapper(final Type target) {
		final ClassMeta<T> classMeta = getClassMeta(target);
		return new DynamicJdbcSetRowMapper<T>(new SetRowMapperFactory<T>(classMeta),  new MapperKeyFactory(),  new MapperKeyFactory());
	}
187634
public void parseForClass(GenericDeclaration genericDecl, String signature) {
        setInput(genericDecl, signature);
        if (!eof) {
            parseClassSignature();
        } else {
            if(genericDecl instanceof Class) {
                Class c = (Class) genericDecl;
                this.formalTypeParameters = EmptyArray.TYPE_VARIABLE;
                this.superclassType = c.getSuperclass();
                Class<?>[] interfaces = c.getInterfaces();
                if (interfaces.length == 0) {
                    this.interfaceTypes = ListOfTypes.EMPTY;
                } else {
                    this.interfaceTypes = new ListOfTypes(interfaces);
                }
            } else {
                this.formalTypeParameters = EmptyArray.TYPE_VARIABLE;
                this.superclassType = Object.class;
                this.interfaceTypes = ListOfTypes.EMPTY;
            }
        }
    }
509443
public static Map<CompilerConfiguration, Vector<TargetInfo>> getTargetsToBuildByConfiguration(
      final Map<String, TargetInfo> targets) {
    final Map<CompilerConfiguration, Vector<TargetInfo>> targetsByConfig = new HashMap<>();
    for (final TargetInfo target : targets.values()) {
      if (target.getRebuild()) {
        // FIXME: Types do not match between the key of targetsByConfig and the return value of target.getConfiguration
        Vector<TargetInfo> targetsForSameConfig = targetsByConfig.get(target.getConfiguration());
        if (targetsForSameConfig != null) {
          targetsForSameConfig.addElement(target);
        } else {
          targetsForSameConfig = new Vector<>();
          targetsForSameConfig.addElement(target);
          targetsByConfig.put((CompilerConfiguration) target.getConfiguration(), targetsForSameConfig);
        }
      }
    }
    return targetsByConfig;
  }