Filter this {@link ClassInfoList} to include only {@link Enum} classes.

@return The filtered list, containing only enums.
482314
public ClassInfoList getEnums() {
        return filter(new ClassInfoFilter() {
            @Override
            public boolean accept(final ClassInfo ci) {
                return ci.isEnum();
            }
        });
    }
913670
public List<FilterMappingType<WebAppType<T>>> getAllFilterMapping()
   {
      List<FilterMappingType<WebAppType<T>>> list = new ArrayList<FilterMappingType<WebAppType<T>>>();
      List<Node> nodeList = childNode.get("filter-mapping");
      for(Node node: nodeList)
      {
         FilterMappingType<WebAppType<T>>  type = new FilterMappingTypeImpl<WebAppType<T>>(this, "filter-mapping", childNode, node);
         list.add(type);
      }
      return list;
   }
844764
public ClassDoc[] allClasses(boolean filter) {
        List<ClassDocImpl> classes = getClasses(filter);
        return classes.toArray(new ClassDocImpl[classes.length()]);
    }
668889
public static List<Class<?>> getAllClasses(Class<?> clazz) {
        List<Class<?>> types = new ArrayList<>();
        while (clazz != null) {
            types.add(clazz);
            clazz = clazz.getSuperclass();
        }
        return types;
    }
938266
@Nonnull
    public static <T> List<T> filter( @Nonnull Iterable<?> base, @Nonnull Class<T> type ) {
        List<T> r = new ArrayList<>();
        for (Object i : base) {
            if(type.isInstance(i))
                r.add(type.cast(i));
        }
        return r;
    }
804983
public JClass []getParameterTypes()
  {
    String descriptor = getDescriptor();

    ArrayList<JClass> typeList = new ArrayList<JClass>();

    int i = 0;
    while ((i = nextDescriptor(descriptor, i)) >= 0) {
      typeList.add(getClassLoader().descriptorToClass(descriptor, i));
    }

    JClass []types = new JClass[typeList.size()];

    typeList.toArray(types);

    return types;
  }
1163050
private List<ClassDocImpl> getClasses(boolean filtered) {
        if (allClasses != null && !filtered) {
            return allClasses;
        }
        if (allClassesFiltered != null && filtered) {
            return allClassesFiltered;
        }
        ListBuffer<ClassDocImpl> classes = new ListBuffer<>();
        for (Symbol enumerated : sym.members().getSymbols(NON_RECURSIVE)) {
            if (enumerated != null) {
                ClassSymbol s = (ClassSymbol)enumerated;
                ClassDocImpl c = env.getClassDoc(s);
                if (c != null && !c.isSynthetic())
                    c.addAllClasses(classes, filtered);
            }
        }
        if (filtered)
            return allClassesFiltered = classes.toList();
        else
            return allClasses = classes.toList();
    }
57658
@Nonnull
    public static <T> List<T> filter( @Nonnull List<?> base, @Nonnull Class<T> type ) {
        return filter((Iterable)base,type);
    }
131773
private static <T> List<T> filterSelection(Class<T> clazz,
      IStructuredSelection selection) {
    List<T> list = new ArrayList<T>();
    for (Object obj : selection.toList()) {
      if (clazz.isAssignableFrom(obj.getClass())) {
        list.add((T) obj);
      }
    }
    return list;
  }
390923
public List<Class<Enum>> getOptionGroups() {
        return getOptions().stream().<Class<Enum>>map(Enum::getDeclaringClass).distinct()
                .sorted(Comparator.comparing(Class::getSimpleName))
                .collect(Collectors.toList());
    }
22434
public SortedSet<TypeElement> allUnnamedClasses() {
        for (PackageElement pkg : allClasses.keySet()) {
            if (pkg.isUnnamed()) {
                return allClasses.get(pkg);
            }
        }
        return new TreeSet<>(comparator);
    }
751372
public List<FilterType<PortletAppType<T>>> getAllFilter()
   {
      List<FilterType<PortletAppType<T>>> list = new ArrayList<FilterType<PortletAppType<T>>>();
      List<Node> nodeList = childNode.get("filter");
      for(Node node: nodeList)
      {
         FilterType<PortletAppType<T>>  type = new FilterTypeImpl<PortletAppType<T>>(this, "filter", childNode, node);
         list.add(type);
      }
      return list;
   }
1281331
public <T extends TypeDefinition> List<T> getTypes(Class<T> targetClass) {
        return types.values().stream()
                .filter(targetClass::isInstance)
                .map(targetClass::cast)
                .collect(Collectors.toList());
    }
361085
public CmsRelationFilter filterInternal() {

        CmsRelationFilter filter = (CmsRelationFilter)clone();
        if (filter.m_types.isEmpty()) {
            filter.m_types.addAll(CmsRelationType.getAllInternal());
        } else {
            filter.m_types = new HashSet<CmsRelationType>(CmsRelationType.filterInternal(filter.m_types));
        }
        return filter;
    }
153864
public <E extends Element> List<E> filterElements(Class<E> clazz) {
		synchronized(lock) {
			if(elements == null) return Collections.emptyList();
			return AoCollections.filter(elements, clazz);
		}
	}
1369156
public java.util.List<DocumentFilter> getDocumentFilterList() {
        if (documentFilterList == null) {
            documentFilterList = new com.amazonaws.internal.SdkInternalList<DocumentFilter>();
        }
        return documentFilterList;
    }
189754
public <T extends Enum<T>> List<T> getEnumList(final String param, final Class<T> clazz) {
    return this.getList(param, new StringToEnum<>(clazz), new AlwaysValid<T>(), "enumeration");
  }