Test whether or not a name matches against at least one exclude
pattern.

@param name The name to match. Must not be <code>null</code>.
@return <code>true</code> when the name matches against at least one
exclude pattern, or <code>false</code> otherwise.
426513
protected boolean isExcluded(String name) {
        ensureNonPatternSetsReady();

        if (isCaseSensitive()
            ? excludeNonPatterns.contains(name)
            : excludeNonPatterns.contains(name.toUpperCase())) {
            return true;
        }
        for (int i = 0; i < excludePatterns.length; i++) {
            if (matchPath(excludePatterns[i], name, isCaseSensitive())) {
                return true;
            }
        }
        return false;
    }
1281901
private boolean doesMatchFullName(String firstName, String fullName){
        boolean matching = false;
        if(firstName != null && !firstName.isEmpty() && fullName != null && !fullName.isEmpty()){
            String firstFromCMDB;
            String[] array = fullName.split(" ");

            firstName = firstName.toLowerCase();
            firstFromCMDB = array[0];
            firstFromCMDB = firstFromCMDB.toLowerCase();
            if(firstFromCMDB.length() < firstName.length()){
                if(firstName.indexOf(firstFromCMDB) != -1){
                    matching = true;
                }
            }else if (firstFromCMDB.indexOf(firstName) != -1){
                matching = true;
            }
        }
        return matching;
    }
1276310
public static boolean isValid(final String name) {
        if (name == null) {
            return true;
        }
        for (final FileOrder fo : INSTANCES) {
            if (fo.name.equals(name)) {
                return true;
            }
        }
        return false;
    }
1213279
private static boolean containsIgnoreCase(List<String> names, String nameToFind) {
		if (CollUtil.isEmpty(names)) {
			return false;
		}
		if (StrUtil.isEmpty(nameToFind)) {
			return false;
		}
		for (String name : names) {
			if (nameToFind.equalsIgnoreCase(name)) {
				return true;
			}
		}
		return false;
	}
257413
boolean isAccepted(final String name) {
        for (String str : charsets) {
            if (str.equalsIgnoreCase(name)) {
                return true;
            }
        }
        return false;
    }
318404
@VisibleForTesting
	public boolean onlyKeyExists(String name) {
		String[] names = handleDeprecation(deprecationContext.get(), name);
		for(String n : names) {
			if ( getProps().getProperty(n,DEFAULT_STRING_CHECK)
					.equals(DEFAULT_STRING_CHECK) ) {
				return true;
			}
		}
		return false;
	}
951514
public boolean containsMethod(final String name) {
      if (StringUtils.isNullOrBlank(name)) {
         return false;
      }
      return ClassDescriptorCache.getInstance()
                                 .getClassDescriptor(clazz)
                                 .getMethods(accessAll)
                                 .stream()
                                 .anyMatch(f -> f.getName().equals(name));
   }
234061
public static boolean isValid(final String name) {
        if (name == null) {
            return true;
        }
        for (final FileHandlerResult result : INSTANCES) {
            if (result.name.equals(name)) {
                return true;
            }
        }
        return false;
    }
970277
public boolean contains(QualifiedName name) {
		Name unit = name.getUnit();
		// Get information associated with this unit
		SymbolTable.Group group = symbolTable.get(unit);
		return group != null && group.isValid(name.getName());
	}
520128
public static boolean isClass(String name)
  {
    if(name == null) {
      return false;
    }
    Matcher matcher = CLASS_NAME_PATTERN.matcher(name);
    return matcher.find();
  }
178867
public static boolean isMemberName(String name)
  {
    if(name == null) {
      return false;
    }
    Matcher matcher = MEMBER_NAME_PATTERN.matcher(name);
    return matcher.find();
  }
715216
public boolean contains( String name )
    {
        for ( Header header : headers ) {
            if ( header.getName().equals( name ) ) {
                return true;
            }
        }
        return false;
    }
1256369
protected static final boolean looksLikeAnnotationName(final String name) {
        return name.startsWith("org.nmdp") && Character.isUpperCase(name.charAt(name.lastIndexOf(".") + 1));
    }
866786
public boolean shouldIgnore(MaterialConfig materialConfig, String name) {
        return materialConfig.matches(FilenameUtils.separatorsToUnix(name), processedPattern());
    }
1362850
public static boolean charValidate(String name) {
        if (name.matches("[0-9]+") || name.toLowerCase().equals("null")) {
            return false;
        } else {
            return name.matches("[a-zA-Z0-9-_.]+");
        }
    }
1252979
public static void checkResourceName(String name) {
        if (name == null || (!name.isEmpty() && !name.matches("^[a-zA-Z0-9_;\\-\\.\\[\\]\\(\\)]+$"))) {
            throw new IllegalArgumentException("name(" + name + ") contains illegal character, must be (a-z,A-Z,0-9,_,.,(,),-,[,])");
        }
    }
1153360
def match(self, name):
		''''''
		if (self.ns + self.name).startswith(name):
			return True

		for alias in self.aliases:
			if (self.ns + alias).startswith(name):
				return True