Returns whether the given annotation is a mapped annotation.

@param annotationName The annotation name
@return True if it is
545185
@Internal
    public static boolean isAnnotationMapped(@Nullable String annotationName) {
        return annotationName != null && ANNOTATION_MAPPERS.containsKey(annotationName);
    }
1186769
public static void mapping(String mappedFieldName, String mappedClassName){
		throw new MappingErrorException(MSG.INSTANCE.message(mappingErrorException2length,mappedFieldName,mappedClassName));
	}
33016
public static IAnnotationBinding getAnnotationBinding(
            IAnnotationBinding[] annotations, String annotationClassName) {
        if (annotations == null) {
            return null;
        }
        if (annotationClassName == null) {
            throw new NullPointerException();
        }

        for (IAnnotationBinding annotation : annotations) {
            String qName = annotation.getAnnotationType().getBinaryName();
            assert qName != null;
            // TODO if multiple annotations for annotationClassName exists
            if (qName.equals(annotationClassName)) {
                return annotation;
            }
        }
        return null;
    }
614251
public static boolean hasFXBindableAnnotation(AnnotatedNode node) {
        for (AnnotationNode annotation : node.getAnnotations()) {
            if (FXBINDABLE_CNODE.equals(annotation.getClassNode())) {
                return true;
            }
        }
        return false;
    }
681108
public static boolean hasDbBind(Annotation[] annotations) {
        final String name = DB_BIND_CNAME;
        for (Annotation a : annotations) {
            if (a.annotationType().getName().equals(name)) {
                return true;
            }
        }
        return false;
    }
247799
public static boolean hasAnnotation(ExecutableElement method, Class<? extends Annotation> ann) {
        List<? extends AnnotationMirror> annotationMirrors = method.getAnnotationMirrors();
        for (AnnotationMirror annotationMirror : annotationMirrors) {
            if (annotationMirror.getAnnotationType().toString().equals(ann.getName())) {
                return true;
            }
        }
        return false;
    }
314230
@SuppressWarnings({ "rawtypes", "unchecked" })
    private static boolean isAnnotated(final Class clazz) {
        Plugin plugin = (Plugin) clazz.getAnnotation(Plugin.class);
        return plugin != null;
    }
422891
public static boolean isDAOValidatorAnnotation(Annotation annotation) {
		
		// Si lm'annotation est nulle
		if(annotation == null) {
			
			// On retourne false
			return false;
		}
		
		// Obtention de la classe de cette annotation
		Class<?> annotationClass = annotation.annotationType();
		
		// Recherchje de l'annotation de validation
		DAOConstraint logicAnnotation = annotationClass.getAnnotation(DAOConstraint.class);
		
		// On retourne le resultat
		return logicAnnotation != null;
	}
4233
public boolean containsPropertySet(Class<? extends Annotation> propertySet)
    {
        if (_annotElem.isAnnotationPresent(propertySet))
            return true;

        //
        // Call up to superclass for delegation
        //
        return super.containsPropertySet(propertySet);
    }
167284
@SuppressWarnings("static-method")
	protected boolean isForbiddenActiveAnnotation(XAnnotation annotation) {
		final String name = annotation.getAnnotationType().getQualifiedName();
		return Strings.equal(EqualsHashCode.class.getName(), name)
				|| Strings.equal(FinalFieldsConstructor.class.getName(), name);
	}
1315364
public boolean hasMapping(String tableName, long baseId, long relatedId) {
		UserMappingDao userMappingDao = getMappingDao(tableName);
		return userMappingDao.countByIds(baseId, relatedId) > 0;
	}
270900
private static boolean exemptedByAnnotation(
      List<? extends AnnotationTree> annotations,
      VisitorState state) {
    for (AnnotationTree annotation : annotations) {
      if (((JCAnnotation) annotation).type != null) {
        TypeSymbol tsym = ((JCAnnotation) annotation).type.tsym;
        if (EXEMPTING_METHOD_ANNOTATIONS.contains(tsym.getQualifiedName().toString())) {
          return true;
        }
      }
    }
    return false;
  }
1111999
public static boolean hasAnnotation(final MethodNode methodNode, final Class<? extends Annotation> annotationClass) {
        return !methodNode.getAnnotations(new ClassNode(annotationClass)).isEmpty();
    }
1319719
static Optional<AnnotationTree> findAnnotation(String annotationName, ClassTree classTree) {
    for (AnnotationTree annotationTree : classTree.getModifiers().getAnnotations()) {
      ClassSymbol annotationClass = (ClassSymbol) getSymbol(annotationTree.getAnnotationType());
      if (annotationClass.fullname.contentEquals(annotationName)) {
        return Optional.of(annotationTree);
      }
    }
    return Optional.absent();
  }
1172111
private boolean hasAnnotation(Class c, Class targetClass, AnnotationRepository annotationRepository)
   {
      Collection<Annotation> values = annotationRepository.getAnnotation(targetClass);
      if (values == null)
         return false;
      for (Annotation annotation : values)
      {
         if (annotation.getClassName() != null && annotation.getClassName().equals(c.getName()))
            return true;
      }
      return false;

   }
178752
public static boolean isDocumentedAnnotation(AnnotationTypeDoc annotationDoc) {
        AnnotationDesc[] annotationDescList = annotationDoc.annotations();
        for (int i = 0; i < annotationDescList.length; i++) {
            if (annotationDescList[i].annotationType().qualifiedName().equals(
                   java.lang.annotation.Documented.class.getName())){
                return true;
            }
        }
        return false;
    }
22866
@SuppressWarnings("unchecked")
    protected Class<? extends Annotation> annotationTypeForName(String name) {
        try {
            return (Class<? extends Annotation>) resourceLoader.classForName(name);
        } catch (ResourceLoadingException cnfe) {
            return DUMMY_ANNOTATION;
        }
    }