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

@return
330006
@SuppressWarnings("unchecked")
    public Collection<TopicAnnotation> getTopicAnnotations() {
        Collection<? extends Enhancement> result = enhancements.get(TopicAnnotation.class);
        return result == null ? Collections.<TopicAnnotation>emptySet() : 
            Collections.unmodifiableCollection((Collection<TopicAnnotation>) result);
    }
666326
private static List<Annotation> getAnnotations(Method method) {
		if (methodAnnotationCache.containsKey(method)) {
			return methodAnnotationCache.get(method);
		}
		List<Annotation> annotations = new ArrayList<>();
		Collections.addAll(annotations, method.getAnnotations());
		annotations = Collections.unmodifiableList(annotations);
		methodAnnotationCache.put(method, annotations);
		return annotations;
	}
1088114
public List<String> getAnnotations() {
        AnnotationBuilder result = new AnnotationBuilder();
        result.add( //
                getFixedLengthAnnotation(), //
                getLengthAnnotation(), //
                getNotNullAnnotation(), //
                getNotEmptyAnnotation(), //
                getCharPaddingAnnotation(), //
                getEmailAnnotation(), //
                getDigitsAnnotation(), //
                getSafeHtmlAnnotation(), //
                getUrlAnnotation());
        return result.getAnnotations();
    }
838369
public List<String> getAccessorAnnotationDescriptors() {
        if (mAnnotationDescs == null) {
            return Collections.emptyList();
        }
        return Collections.unmodifiableList(mAnnotationDescs);
    }
531274
public Annotation[] getAnnotations() {
		final XAnnotation<?>[] xannotations = getXAnnotations();
		final Annotation[] annotations = new Annotation[xannotations.length];
		for (int index = 0; index < xannotations.length; index++) {
			annotations[index] = xannotations[index].getResult();
		}
		return annotations;
	}
219675
@Override
    public List<AnnotationInfoImpl> getAnnotations() {
        if (annotations != null) {
            return annotations;
        }

        // Several cases where superclasses contribute no annotations.  In
        // each of these cases case, simply re-use the declared annotations
        // collection.
        //
        // (One case: All of the inheritable superclass annotations is
        // overridden by the immediate class, is not detected.)

        ClassInfoImpl useSuperClass = getSuperclass(); // Null for 'java.lang.Object'; null for interfaces.  
        if (useSuperClass == null) {
                annotations = declaredAnnotations;
            return annotations;
                    }

        // Retrieve *all* annotations of the superclass.  The effect
        // is to recurse across annotations of all superclasses.

        List<AnnotationInfoImpl> superAnnos = useSuperClass.getAnnotations();
        if (superAnnos.isEmpty()) {
            annotations = declaredAnnotations;
            return annotations;
                }

        Map<String, AnnotationInfoImpl> allAnnotations =
                        new HashMap<String, AnnotationInfoImpl>(superAnnos.size() + declaredAnnotations.size(), 1.0f);

        boolean sawInherited = false;
        for (AnnotationInfoImpl superAnno : superAnnos) {
            if (sawInherited = superAnno.isInherited()) {
                allAnnotations.put(superAnno.getAnnotationClassName(), superAnno);
            }
                }

        if (!sawInherited) {
            annotations = declaredAnnotations;
            return annotations;
        }

        // Make sure to add the declared annotations *after* adding the super class
        // annotations.  The immediate declared annotations have precedence.

        // We could test the number of overwritten annotations against the
        // number of inherited annotations.  That case seems infrequent, and
        // is not implemented.

        for (AnnotationInfoImpl declaredAnno : declaredAnnotations) {
            AnnotationInfoImpl overwrittenAnno = allAnnotations.put(declaredAnno.getAnnotationClassName(), declaredAnno);
            if (overwrittenAnno != null) {
                // NO-OP: But maybe we want to log this
            }
        }

        annotations = new ArrayList<AnnotationInfoImpl>(allAnnotations.values());
        return annotations;
    }
299406
public static List<SQLProperty> extractUsedProperties(Builder methodBuilder, SQLiteModelMethod method, Class<? extends Annotation> annotationClazz) {
		SQLiteEntity entity = method.getEntity();
		List<SQLProperty> listPropertyInContentValue = new ArrayList<SQLProperty>();

		Set<String> foundColumns = JQLChecker.getInstance().extractColumnsToInsertOrUpdate(method, method.jql.value, entity);

		// for each property in entity except primaryKey and excluded properties
		for (SQLProperty item : entity.getCollection()) {
			if (foundColumns.size() > 0 && !foundColumns.contains(item.getName())) {
				continue;
			}

			// add property to list of used properties
			listPropertyInContentValue.add(item);
		}

		return listPropertyInContentValue;

	}
1235934
public List<String> getAnnotations() {
        AnnotationBuilder annotations = new AnnotationBuilder();
        annotations.add( //
                getFieldAnnotation(), //
                getFieldBridgeAnnotation(), //
                getTikaBridgeAnnotation());
        return annotations.getAnnotations();
    }
1348482
public List<EntityResult<SqlResultSetMapping<T>>> getAllEntityResult()
   {
      List<EntityResult<SqlResultSetMapping<T>>> list = new ArrayList<EntityResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("entity-result");
      for(Node node: nodeList)
      {
         EntityResult<SqlResultSetMapping<T>>  type = new EntityResultImpl<SqlResultSetMapping<T>>(this, "entity-result", childNode, node);
         list.add(type);
      }
      return list;
   }
896858
public static <T extends Entity<?>> List<?> extractIds(Collection<T> entities) {
    List<Object> idList = CollectUtils.newArrayList();
    for (Iterator<T> iter = entities.iterator(); iter.hasNext();) {
      Entity<?> element = iter.next();
      try {
        idList.add(PropertyUtils.getProperty(element, "id"));
      } catch (Exception e) {
        logger.error("getProperty error", e);
        continue;
      }
    }
    return idList;
  }
1116952
public List<Excerpt> getAccessorAnnotations() {
    if (accessorAnnotations instanceof ImmutableList) {
      accessorAnnotations = new ArrayList<>(accessorAnnotations);
    }
    return Collections.unmodifiableList(accessorAnnotations);
  }
335490
public List<MappedField> getFieldsAnnotatedWith(final Class<? extends Annotation> clazz) {
        final List<MappedField> results = new ArrayList<MappedField>();
        for (final MappedField mf : persistenceFields) {
            if (mf.hasAnnotation(clazz)) {
                results.add(mf);
            }
        }
        return results;
    }
131581
@Override
    public List<EntityDeclaration> getEntities()
    {
        if (mEntities == null && (mSubset != null)) {
            /* Better make a copy, so that caller can not modify list
             * DTD has, which may be shared (since DTD subset instances
             * are cached and reused)
             */
            mEntities = new ArrayList<EntityDeclaration>(mSubset.getGeneralEntityList());
        }
        return mEntities;
    }
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();
  }
38724
public List<MappedSuperclass<EntityMappings<T>>> getAllMappedSuperclass()
   {
      List<MappedSuperclass<EntityMappings<T>>> list = new ArrayList<MappedSuperclass<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("mapped-superclass");
      for(Node node: nodeList)
      {
         MappedSuperclass<EntityMappings<T>>  type = new MappedSuperclassImpl<EntityMappings<T>>(this, "mapped-superclass", childNode, node);
         list.add(type);
      }
      return list;
   }
630996
public static List<Link> getLinks(final AnnotatedElement annotatedElement) {
        final List<Link> result = new ArrayList<>();
        result.addAll(extractLinks(annotatedElement, io.qameta.allure.Link.class, ResultsUtils::createLink));
        result.addAll(extractLinks(annotatedElement, io.qameta.allure.Issue.class, ResultsUtils::createLink));
        result.addAll(extractLinks(annotatedElement, io.qameta.allure.TmsLink.class, ResultsUtils::createLink));
        return result;
    }
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;
    }