TODO private final Set<String> excludedIssues;
483186
public static Form form() {
        return Form.create()
                .with(defaultNameField())
                .url()
                .with(Text.of("user").label("User").length(16).optional())
                .with(Password.of("password").label("Password").length(40).optional());
    }
630053
private Set<K> determineExcludedKeys(IntFunction<Set<K>> keysToExclude, IntSet segmentsToUse) {
      if (keysToExclude == null) {
         return Collections.emptySet();
      }

      // Special map only supports get operations
      return segmentsToUse.intStream().mapToObj(s -> {
         Set<K> keysForSegment = keysToExclude.apply(s);
         if (keysForSegment != null) {
            return keysForSegment.stream();
         }
         return null;
      }).flatMap(Function.identity()).collect(Collectors.toSet());
   }
1103102
public void setExcludeList(List<String> ignoredRegexs) {
		if (ignoredRegexs == null || ignoredRegexs.isEmpty()) {
			excludeList = Collections.emptyList();
			return;
		}

		this.excludeList = ignoredRegexs;
	}
581456
public List<String> getExcludedTables() {
        List<String> dbTables = project.readDataList("data.excluded.tables");
        if (dbTables == null)
            dbTables = DEFAULT_EXCLUDED_TABLES;
        return dbTables;
    }
1267087
@Override
    public ResponseToRoom ignore(String... params) {
        excludedVars.addAll(Arrays.asList(params));
        return this;
    }
997769
private void excludeByFeatCount(IntIntDenseVector[][] counts) {
        for (int t=0; t<included.length; t++) {
            for (int c = 0; c < included[t].length; c++) {
                for (int k = 0; k < included[t][c].length; k++) {
                    boolean exclude = (counts[t][c].get(k) < prm.featCountCutoff);
                    if (exclude) {
                        included[t][c][k] = false;
                    }
                }
            }
        }
    }
344077
public function getExcludedIds()
    {
        $excludedIdsString = $this->getRequest()->get('excludedIds');

        return (null !== $excludedIdsString) ? array_filter(explode(',', $excludedIdsString)) : [];
    }
596056
public final void containsNoneIn(Iterable<?> excluded) {
    Collection<?> actual = iterableToCollection(actual());
    Collection<Object> present = new ArrayList<>();
    for (Object item : Sets.newLinkedHashSet(excluded)) {
      if (actual.contains(item)) {
        present.add(item);
      }
    }
    if (!present.isEmpty()) {
      failWithoutActual(
          fact("expected not to contain any of", annotateEmptyStrings(excluded)),
          fact("but contained", annotateEmptyStrings(present)),
          fullContents());
    }
  }
832466
function excludeElements(exclude) {
      return Array.isArray(exclude) ? exclude.forEach(function(selector) {
        // Use querySelectorAll to hide all dom element with the specified selector
        var selectorAll = document.querySelectorAll(selector);

        if(selectorAll.length) {
          // Interate through NodeList
          for(var i = 0; i < selectorAll.length; i++) {
            selectorAll.item(i).style.visibility = 'hidden';
          }
        }
      }) : false;
    }
899547
private void setupFilters(Analyzer analyzer) {
		String exclude = analyzer.getProperty("importless.packager.excludes");
		String[] excludesAll = exclude.split(",");
		for (String excludesIndividual:excludesAll) {
			if (excludesIndividual.endsWith("*"))
				excludePrefixes.add(excludesIndividual.substring(0,excludesIndividual.length()-1));
			else 
				excludes.add(excludesIndividual);
		}
		System.out.println("excludePrefixes: " + excludePrefixes +" excludes: " + excludes);
	}
47168
function shouldExclude(sets) {
        for (var i = 0; i < sets.length; ++i) {
            if (!(sets[i] in exclude)) {
                return false;
            }
        }
        return true;
    }
730468
@Nullable
    private static <T> ArrayList<T> excludeObject(@Nullable ArrayList<T> list, @Nullable T target, boolean exclude) {
        if (target != null) {
            if (exclude) {
                list = ArrayListManager.add(list, target);
            } else {
                list = ArrayListManager.remove(list, target);
            }
        }
        return list;
    }
1106010
public void setExclusionArns(java.util.Collection<String> exclusionArns) {
        if (exclusionArns == null) {
            this.exclusionArns = null;
            return;
        }

        this.exclusionArns = new java.util.ArrayList<String>(exclusionArns);
    }
573252
public static boolean isExcluded(String filename, List<String> excludes) {
        logger.debug("filename = [{}], excludes = [{}]", filename, excludes);

        // No rules ? Fine, we index everything
        if (excludes == null || excludes.isEmpty()) {
            logger.trace("no rules");
            return false;
        }

        // Exclude rules : we know that whatever includes rules are, we should exclude matching files
        for (String exclude : excludes) {
            String regex = exclude.toLowerCase().replace("?", ".?").replace("*", ".*?");
            logger.trace("regex is [{}]", regex);
            if (filename.toLowerCase().matches(regex)) {
                logger.trace("does match exclude regex");
                return true;
            }
        }

        logger.trace("does not match any exclude pattern");
        return false;
    }
1160974
private boolean isExcluded(String name, String cmpname, String value) {
        return exclude.contains(excludeKey(name, null, value)) || exclude.contains(excludeKey(name, cmpname, value));
    }
681818
public boolean isExcluded(String endpoint) {
        for (int i = 0; i < exclusions.size(); i++) {
            if (exclusions.get(i).test(endpoint)) {
                return true;
            }
        }
        return false;
    }
545216
private boolean matchesExcludes( final String fileName )
    {
        for( Pattern include : m_excludes )
        {
            if( include.matcher( fileName ).matches() )
            {
                return true;
            }
        }
        return false;
    }