a map of provided classes and class members, and what
        provides them. ignored is an optional list of globbed patterns
        indicating packages, classes, etc that shouldn't be included
        in the provides map
321839
def get_provides(self, ignored=tuple()):
        

        if self._provides is None:
            self._collect_requires_provides()

        d = self._provides
        if ignored:
            d = dict((k, v) for k, v in d.items()
                     if not fnmatches(k, *ignored))
        return d
1155471
function (element, ignoredClasses) {

	this.element = element;
	this.isDirectChild = true;
	this.tag = element.localName;
	this.tag = this.tag.replace(/:/g, '\\:');

	// nth-of-child(n+1)
	this.indexn = null;
	this.index = 1;
	this.id = null;
	this.classes = new Array();

	// do not add additinal info to html, body tags.
	// html:nth-of-type(1) cannot be selected
	if(this.tag === 'html' || this.tag === 'HTML'
		|| this.tag === 'body' || this.tag === 'BODY') {
		this.index = null;
		return;
	}

	if (element.parentNode !== undefined) {
		// nth-child
		//this.index = [].indexOf.call(element.parentNode.children, element)+1;

		// nth-of-type
		for (var i = 0; i < element.parentNode.children.length; i++) {
			var child = element.parentNode.children[i];
			if (child === element) {
				break;
			}
			if (child.tagName === element.tagName) {
				this.index++;
			}
		}
	}

	if (element.id !== '') {
		if (typeof element.id === 'string') {
			this.id = element.id;
			this.id = this.id.replace(/:/g, '\\:');
		}
	}

	for (var i = 0; i < element.classList.length; i++) {
		var cclass = element.classList[i];
		if (ignoredClasses.indexOf(cclass) === -1) {
			cclass = cclass.replace(/:/g, '\\:');
			this.classes.push(cclass);
		}
	}
}
745508
private Set<Class<?>> getClasses() {
		HashSet<Class<?>> result = new HashSet<Class<?>>();
		
		// in case of override only the last global configuration must be analyzed
		JGlobalMap jGlobalMap = null;
		
		for (Class<?> clazz : getAllsuperClasses(configuredClass)) {
			
			// only if global configuration is null will be searched global configuration on super classes
			if(isNull(jGlobalMap)){
				
				jGlobalMap = clazz.getAnnotation(JGlobalMap.class);
				//if the field configuration is defined in the global map
				if(!isNull(jGlobalMap)){
					addClasses(jGlobalMap.classes(),result);
					if(!isNull(jGlobalMap.excluded()))
						for (Field field : getListOfFields(configuredClass)){ 
							JMap jMap = field.getAnnotation(JMap.class);
							if(!isNull(jMap)) 
								for (String fieldName : jGlobalMap.excluded()) 
									if(field.getName().equals(fieldName))
										addClasses(jMap.classes(),result,field.getName());
						}
					
					return result;
				}
			}
		}
		
		for (Field field : getListOfFields(configuredClass)){ 
			JMap jMap = field.getAnnotation(JMap.class);
			if(!isNull(jMap)) addClasses(jMap.classes(),result,field.getName());
		}	
		
		return result;	
	}
208515
public static Map<String, Object> filter(Map<String, Object> source, String prefix, String include, String exclude, Map<String, String> keyMap) {
    	LinkedHashMap<String, Object> dst = new LinkedHashMap<String, Object>();
    	if (source == null || source.isEmpty())
    		return dst;
    	Pattern includePattern = include == null ? null : Pattern.compile(include);
    	Pattern excludePattern = exclude == null ? null : Pattern.compile(exclude);
    	
    	for (Entry<String, Object> en : source.entrySet()) {
    		String key = en.getKey();
    		if (prefix != null) {
    			if (key.startsWith(prefix))
    				key = key.substring(prefix.length());
    			else
    				continue;
    		}
    		if (includePattern != null && !includePattern.matcher(key).find())
    			continue;
    		if (excludePattern != null && excludePattern.matcher(key).find())
    			continue;
    		if (keyMap != null && keyMap.containsKey(key))
    			dst.put(keyMap.get(key), en.getValue());
    		else
    			dst.put(key, en.getValue());
		}
    	return dst;
    }
720800
static Predicate<CtClass> createExcludePredicate(@Nullable final String[] classes) {
        final Set<PathMatcher> excludeSet;
        if (classes != null && classes.length != 0) {
            excludeSet = createPathMatcherSet(classes);
        } else {
            return ctClass -> false;
        }
        return createMatchingPredicate(excludeSet);
    }
1131940
function (glob, opts) {
    if (opts.ignore) {
      this.map('exclude', opts.ignore, opts);
    }
    if (opts.exclude) {
      this.map('exclude', opts.exclude, opts);
    }
    if (opts.include) {
      this.map('include', opts.include, opts);
    }

    // if not disabled by the user, run the built-ins
    if (!this.disabled('builtins')) {
      if (!this.disabled('npm')) {
        this.use(npm(opts));
      }
      if (!this.disabled('dotfiles')) {
        this.use(dotfiles()(opts));
      }
      if (!this.disabled('gitignore')) {
        this.use(gitignore()(opts));
      }
    }
  }
1177434
private boolean shouldExcludeSourceFile(CompilationUnitTree tree) {
    Pattern excludedPattern = errorProneOptions.getExcludedPattern();
    return excludedPattern != null
        && excludedPattern.matcher(ASTHelpers.getFileName(tree)).matches();
  }
303396
private static void printNonAffectedClasses(Set<String> allClasses, Set<String> affectedClasses,
            List<String> nonAffectedClasses, String mode) {
        if (mode != null && mode.equals(ANT_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude name=\"" + className + ".java\"/>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_SIMPLE_MODE)) {
            StringBuilder sb = new StringBuilder();
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            System.out.println(sb);
        } else if (mode != null && mode.equals(MAVEN_MODE)) {
            StringBuilder sb = new StringBuilder();
            sb.append("<excludes>");
            for (String className : nonAffectedClasses) {
                className = className.replaceAll("\\.", "/");
                sb.append("<exclude>");
                sb.append(className).append(".java");
                sb.append("</exclude>");
            }
            sb.append("</excludes>");
            System.out.println(sb);
        } else if (mode != null && mode.equals(DEBUG_MODE)) {
            System.out.println("AFFECTED: " + affectedClasses);
            System.out.println("NONAFFECTED: " + nonAffectedClasses);
        } else {
            for (String className : nonAffectedClasses) {
                System.out.println(className);
            }
        }
    }
1194575
def ignore(wrapped):
    
    @functools.wraps(wrapped)
    def _ignore(*args, **kwargs):
        return wrapped(*args, **kwargs)
    _ignore._splpy_optype = _OperatorType.Ignore
    _ignore._splpy_file = inspect.getsourcefile(wrapped)
    return _ignore
1008866
private List<ClassNameWrapper> parseClassDir(ClassLoader cl, File file, String packageName, FileFilter fileFilter) {
    	List<ClassNameWrapper> classNames = new ArrayList<> ();
        File[] listFile = file.listFiles(fileFilter);
        
        for (int i=0; i<listFile.length; i++) {
            File entry = listFile[i];
            if (entry.isDirectory()) {
            	classNames.addAll(parseClassDir (cl, entry, packageName, fileFilter));
            	continue;
            }
            String fileName = entry.toString();
            int pos = fileName.indexOf(packageName);
            if (pos > 0) {
                String className = fileName.substring(pos).replaceAll("\\.class$","").replace(File.separatorChar, '.');
                classNames.add(new ClassNameWrapper(cl, className));
            }
        }
        return classNames;
    }
1067994
def _calculate_unpack_filter(cls, includes=None, excludes=None, spec=None):
    
    include_patterns = cls.compile_patterns(includes or [],
                                            field_name='include_patterns',
                                            spec=spec)
    logger.debug('include_patterns: {}'
                 .format(list(p.pattern for p in include_patterns)))
    exclude_patterns = cls.compile_patterns(excludes or [],
                                            field_name='exclude_patterns',
                                            spec=spec)
    logger.debug('exclude_patterns: {}'
                 .format(list(p.pattern for p in exclude_patterns)))
    return lambda f: cls._file_filter(f, include_patterns, exclude_patterns)
309338
synchronized private void clearCachedStructures() {
        mapsInitialized = false;
        packageMap = new HashMap();
        classSource = new HashMap();
        unqNameTable = null;
        nameSpaceChanged();
    }
340402
public List<IfClassNotAvailable<Exclude<T>>> getAllIfClassNotAvailable()
   {
      List<IfClassNotAvailable<Exclude<T>>> list = new ArrayList<IfClassNotAvailable<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-class-not-available");
      for(Node node: nodeList)
      {
         IfClassNotAvailable<Exclude<T>>  type = new IfClassNotAvailableImpl<Exclude<T>>(this, "if-class-not-available", childNode, node);
         list.add(type);
      }
      return list;
   }
1008036
private synchronized boolean isIncluded(String _clazzName) {
        if (includes.size() > 0) {
            for (String include : includes) {
                if (_clazzName.startsWith(include)) {
                    return true;

                }
            }
        } // if we dont have a list, we include nothing (to prevent circular classloader dependencies)
        return false;
    }
288549
protected boolean checkExcludePackages(String classPackageName) {
		if (excludePackages != null && excludePackages.length > 0) {
			WildcardHelper wildcardHelper = new WildcardHelper();

			// we really don't care about the results, just the boolean
			Map<String, String> matchMap = new HashMap<String, String>();

			for (String packageExclude : excludePackages) {
				int[] packagePattern = wildcardHelper.compilePattern(packageExclude);
				if (wildcardHelper.match(matchMap, classPackageName, packagePattern)) {
					return false;
				}
			}
		}
		return true;
	}
926030
private Map<Class<?>, InterfaceInfo> getInterfaceInfoMap() {

        if (interfaceInfoMap == null) {
            interfaceInfoMap = new HashMap<Class<?>, InterfaceInfo>();
            for (final Class<?> c : packageClasses) {
                if (INTERESTING_CLASSES.accept( c )) {
                    if (!interfaceInfoMap.containsKey( c )) {
                        interfaceInfoMap.put( c, new InterfaceInfo( c ) );
                    }
                } else {
                    final Contract contract = c.getAnnotation( Contract.class );
                    if (contract != null) {
                        InterfaceInfo ii = interfaceInfoMap.get( contract.value() );
                        if (ii == null) {
                            ii = new InterfaceInfo( contract.value() );
                            interfaceInfoMap.put( contract.value(), ii );
                        }
                        ii.add( c );
                    }
                }
            }
        }
        return interfaceInfoMap;
    }
159379
private boolean isIncluded(String className) {
    if (includes == null || includes.size() == 0) {
      // generate nothing if no include defined - it makes no sense to generate for all classes from classpath
      return false;
    }
    return includes.stream()
        .filter(pattern -> SelectorUtils.matchPath(pattern, className, ".", true))
        .count() > 0;
  }