Returns the {@link Collection} of extracted {@link EntityAnnotation}s

@return
177609
@SuppressWarnings("unchecked")
    public Collection<KeywordAnnotation> getKeywordAnnotations() {
        Collection<? extends Enhancement> result = enhancements.get(KeywordAnnotation.class);
        return result == null ? Collections.<KeywordAnnotation>emptySet() : 
            Collections.unmodifiableCollection((Collection<KeywordAnnotation>) result);
    }
18576
public List<TableGenerator<EntityMappings<T>>> getAllTableGenerator()
   {
      List<TableGenerator<EntityMappings<T>>> list = new ArrayList<TableGenerator<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("table-generator");
      for(Node node: nodeList)
      {
         TableGenerator<EntityMappings<T>>  type = new TableGeneratorImpl<EntityMappings<T>>(this, "table-generator", childNode, node);
         list.add(type);
      }
      return list;
   }
543917
public String getAnnotations() {
    StringBuilder sb = new StringBuilder(40);
    sb.append("Disambiguator log: \n");
    for (AnalyzedTokenReadings element : tokens) {
      if (!element.isWhitespace() &&
              !"".equals(element.getHistoricalAnnotations())) {
        sb.append(element.getHistoricalAnnotations());
        sb.append('\n');
      }
    }
    return sb.toString();
  }
716656
public List<String> getAnnotations() {
        AnnotationBuilder result = new AnnotationBuilder();
        result.add(getNotNullAnnotation());
        return result.getAnnotations();
    }
1235219
public List<NamedEntityGraph<Entity<T>>> getAllNamedEntityGraph()
   {
      List<NamedEntityGraph<Entity<T>>> list = new ArrayList<NamedEntityGraph<Entity<T>>>();
      List<Node> nodeList = childNode.get("named-entity-graph");
      for(Node node: nodeList)
      {
         NamedEntityGraph<Entity<T>>  type = new NamedEntityGraphImpl<Entity<T>>(this, "named-entity-graph", childNode, node);
         list.add(type);
      }
      return list;
   }
800066
public List<Converter<EntityMappings<T>>> getAllConverter()
   {
      List<Converter<EntityMappings<T>>> list = new ArrayList<Converter<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("converter");
      for(Node node: nodeList)
      {
         Converter<EntityMappings<T>>  type = new ConverterImpl<EntityMappings<T>>(this, "converter", childNode, node);
         list.add(type);
      }
      return list;
   }
577766
public <A extends Annotation> List<A> getAnnotations(final Class<A> annoClass) {
        Objects.requireNonNull(annoClass, "annoClass should not be null.");
        
        return getAnnotationsByType(expandedAnnos, annoClass);
    }
1032643
public List<NamedNativeQuery<EntityMappings<T>>> getAllNamedNativeQuery()
   {
      List<NamedNativeQuery<EntityMappings<T>>> list = new ArrayList<NamedNativeQuery<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("named-native-query");
      for(Node node: nodeList)
      {
         NamedNativeQuery<EntityMappings<T>>  type = new NamedNativeQueryImpl<EntityMappings<T>>(this, "named-native-query", childNode, node);
         list.add(type);
      }
      return list;
   }
124004
private static Set<Annotation> getAnnotations(final Annotation[] annotations, final Class<? extends Annotation> neededAnnotationType) {
        final Set<Annotation> ret = new HashSet<>();

        for (final Annotation annotation : annotations) {
            annotation.annotationType().getAnnotations();
            final Annotation[] metaAnnotations = annotation.annotationType().getAnnotations();
            for (final Annotation metaAnnotation : metaAnnotations) {
                if (metaAnnotation.annotationType().equals(neededAnnotationType)) {
                    ret.add(annotation);
                }
            }
        }

        return ret;
    }
792900
static Set<String> annotationKeys(Span span) {
    Set<String> annotationKeys = new LinkedHashSet<>();
    String localServiceName = span.localServiceName();
    if (localServiceName == null) return Collections.emptySet();
    for (Annotation a : span.annotations()) {
      // don't index core annotations as they aren't queryable
      if (CORE_ANNOTATIONS.contains(a.value())) continue;
      annotationKeys.add(localServiceName + ":" + a.value());
    }
    for (Map.Entry<String, String> e : span.tags().entrySet()) {
      if (e.getValue().length() <= LONGEST_VALUE_TO_INDEX) {
        annotationKeys.add(localServiceName + ":" + e.getKey());
        annotationKeys.add(localServiceName + ":" + e.getKey() + ":" + e.getValue());
      }
    }
    return annotationKeys;
  }
508415
@SuppressWarnings("unchecked")
    public Collection<TopicAnnotation> getCategories() {
        Collection<? extends Enhancement> result = enhancements.get(TopicAnnotation.class);
        return (Collection<TopicAnnotation>) result; // Should be safe. Needs to be tested
    }
1358756
@Override
	protected Set<Class<? extends Annotation>> getSupportedAnnotationClasses() {
		Set<Class<? extends Annotation>> annotations = new LinkedHashSet<Class<? extends Annotation>>();

		annotations.add(BindType.class);
		annotations.add(BindDataSource.class);
		annotations.add(BindDataSourceOptions.class);
		annotations.add(BindSqlType.class);
		annotations.add(BindDao.class);
		annotations.add(BindDaoMany2Many.class);
		annotations.add(BindGeneratedDao.class);

		return annotations;
	}
315871
private Collection<Field> getDeclaredFields() {
      final LinkedList<Field> declaredFields = new LinkedList<>(Arrays.asList(clazz.getDeclaredFields()));
      for (Class<?> c = clazz.getSuperclass(); c != null; c = c.getSuperclass()) {
         // support fields from MappedSuperclass(es).
         // Do not support ambiguous annotation. Spec says:
         // "A mapped superclass has no separate table defined for it".
         if (c.getAnnotation(MappedSuperclass.class) != null) {
            if (c.getAnnotation(Table.class) == null) {
               declaredFields.addAll(Arrays.asList(c.getDeclaredFields()));
            }
            else {
               throw new RuntimeException("Class " + c.getName() + " annotated with @MappedSuperclass cannot also have @Table annotation");
            }
         }
      }
      return declaredFields;
   }
149349
protected List fetch()
    {
        EntityMetadata metadata = getEntityMetadata();
        Client client = persistenceDelegeator.getClient(metadata);
        List results = isRelational(metadata) ? recursivelyPopulateEntities(metadata, client) : populateEntities(
                metadata, client);
        return results;
    }
899815
public static List<Field> getAnnotatedFields(final Class<?> cls, final Class<? extends Annotation> annotationClass) {

        final List<Field> fieldList = new ArrayList<>();

        for (final Field f : cls.getDeclaredFields()) {
            if (f.getAnnotation(annotationClass) != null) {
                fieldList.add(f);
            }
        }

        // Add super class methods
        if (cls.getSuperclass() != null) {
            fieldList.addAll(getAnnotatedFields(cls.getSuperclass(), annotationClass));
        }

        return fieldList;
    }
1201995
protected List<Map<String, ?>> generateAnnotations() {
		final List<Map<String, ?>> list = new ArrayList<>();
		list.add(pattern(it -> {
			it.matches("\\@[_a-zA-Z$][_0-9a-zA-Z$]*"); //$NON-NLS-1$
			it.style(ANNOTATION_STYLE);
			it.comment("Annotations"); //$NON-NLS-1$
		}));
		return list;
	}
838369
public List<String> getAccessorAnnotationDescriptors() {
        if (mAnnotationDescs == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(mAnnotationDescs);
    }