Return an iterator of L{IPeopleFilter} providers available to this
        organizer's store.
484847
def getPeopleFilters(self):
        
        yield AllPeopleFilter()
        yield VIPPeopleFilter()
        for getPeopleFilters in self._gatherPluginMethods('getPeopleFilters'):
            for peopleFilter in getPeopleFilters():
                yield peopleFilter
        for tag in sorted(self.getPeopleTags()):
            yield TaggedPeopleFilter(tag)
1108541
def _get_enabled():
    """"""
    providers = Provider.objects.all()
    return [p for p in providers if p.enabled()]
859837
def get_collection(self, path, query, **options):
        
        options = self._merge_options(options)
        if options['iterator_type'] == 'items':
            return CollectionPageIterator(self, path, query, options).items()
        if options['iterator_type'] is None:
            return self.get(path, query, **options)
        raise Exception('Unknown value for "iterator_type" option: {}'.format(
            str(options['iterator_type'])))
1127927
protected final Iterator<Page> listChildren(Resource parentResource, PageFilter pageFilter) {
    return new PageIterator(parentResource.listChildren(), pageFilter);
  }
1252293
def iter_extensions(self):
        """"""
        return iter(sorted(self.extensions.values(),
                           key=lambda x: x.priority))
535601
private HashSet<Resource> getResources(GeneratorContext context, JClassType userType, FileFilter filter) {
    final String pack = userType.getPackage().getName().replace('.', '/');

    HashSet<Resource> resourceList = new HashSet<Resource>();
    for (String path : context.getResourcesOracle().getPathNames()) {
      if (!path.startsWith(pack))
        continue;
      String ext = getExtension(path);
      if (EXTENSION_MAP.containsKey(ext))
        resourceList.add(context.getResourcesOracle().getResource(path));
    }

    return resourceList;
  }
1305870
@Override
	public Iterator<Class> getClassesToDeleteIterator() {
		if (fixture instanceof CleanableFixture) {
			return cleanableFixture().getClassesToDeleteIterator();
		}

		return Collections.<Class>emptyList().iterator();
	}
283704
public static List<ProvidesDirective>
            providesIn(Iterable<? extends Directive> directives) {
        return listFilter(directives, DirectiveKind.PROVIDES, ProvidesDirective.class);
    }
239800
public static <T> Iterator<T> filteringIterator(
        Iterator<? extends T> iterator, 
        Predicate<? super T> predicate)
    {
        Objects.requireNonNull(iterator, "The iterator is null");
        Objects.requireNonNull(predicate, "The predicate is null");
        return new FilteringIterator<T>(iterator, predicate);
    }
276158
private ImmutableSet<ImmutableExpression> getExpressionsToPropagateAboveUnion(ImmutableSet<CommutativeJoinOrFilterNode> providers) {
        return providers.stream()
                .map(n -> n.getOptionalFilterCondition().get().flattenAND())
                .reduce(this::computeIntersection).get();
    }
470869
public List<?> getList(PMContext ctx, EntityFilter filter) throws PMException {
        return getList(ctx, filter, null, null, null);
    }
421029
public List<ZuulFilter> getFiltersByType(FilterType filterType) {

        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        list = new ArrayList<ZuulFilter>();

        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                list.add(filter);
            }
        }

        // Sort by filterOrder.
        Collections.sort(list, new Comparator<ZuulFilter>() {
            @Override
            public int compare(ZuulFilter o1, ZuulFilter o2) {
                return o1.filterOrder() - o2.filterOrder();
            }
        });

        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }
977662
def iter_adapters():
    ''''''
    adapters = adapter_catalog.values()
    return sorted(adapters, key=lambda a: a.model.__name__)
913854
private static Iterator<String> getPidIterator(ValidatorProcessParameters parms,
                                                   RemoteObjectSource objectSource)
            throws ObjectSourceException {
        if (parms.getIteratorType() == IteratorType.FS_QUERY) {
            return objectSource.findObjectPids(parms.getQuery());
        } else {
            return new PidfileIterator(parms.getPidfile());
        }
    }
904454
private Iterable<URL> createServiceFileIterator() {
        if (classLoader == null) {
            ClassLoader classLoader = SchemaFactoryFinder.class.getClassLoader();
            return Collections.singleton(classLoader.getResource(SERVICE_ID));
        } else {
            try {
                Enumeration<URL> e = classLoader.getResources(SERVICE_ID);
                if (debug && !e.hasMoreElements()) {
                    debugPrintln("no "+SERVICE_ID+" file was found");
                }

                // wrap it into an Iterator.
                return Collections.list(e);
            } catch (IOException e) {
                if (debug) {
                    debugPrintln("failed to enumerate resources "+SERVICE_ID);
                    e.printStackTrace();
                }
                return Collections.emptySet();
            }
        }
    }
705312
@VisibleForTesting
  public static <T> Iterable<T> getCandidatesViaServiceLoader(Class<T> klass, ClassLoader cl) {
    return ServiceProviders.getCandidatesViaServiceLoader(klass, cl);
  }
318323
public String[] listProviders() {
		String[] providers = new String[container.size()];

		int i = 0;
		Iterator<String> ki = container.keySet().iterator();
		while(ki.hasNext()) {
			providers[i++] = (String) ki.next();	
		}
		
		return providers;
	}