See if there is an alphanumeric
@param textProvider
@return true if matched
497428
public boolean alphaNum(TextProvider textProvider)
        
    {
        clearLastToken(textProvider);
        clearLeadingSpaces(textProvider);
        mark(textProvider);
        if (m_debug)
			debug("testing",textProvider);
        StringBuilder sb = new StringBuilder();
        while (true)
        {
            char c = getNextChar(textProvider);

            if (!Character.isLetterOrDigit(c)) break;
            remark(textProvider);
            sb.append(c);
        }
        reset(textProvider); // removes last char
        if (sb.toString().length() == 0) return false;
        textProvider.setLastToken(sb.toString());
        debug(textProvider);
        return true;
    }
135285
public boolean isNextIn(Context context) {
        return regex == null || regex.matcher(context.getSource().subToEnd()).lookingAt();
    }
919593
private boolean checkText(final Characters paramEvent) {
        assert paramEvent != null;
        final String text = paramEvent.getData().trim();
        return mWtx.getNode().getKind() == IConstants.TEXT && mWtx.getValueOfCurrentNode().equals(text);
    }
724197
public boolean filters(final String aFileExt) {
        final String normalizedExt = normalizeExt(aFileExt);

        for (final String extension : myExtensions) {
            if (extension.equals(normalizedExt)) {
                return true;
            }
        }

        return false;
    }
157436
static boolean matchesProviderDeclaration(final ProviderIdent ident, final Class<?> cls) throws PluginException {
        final Plugin annotation = getPluginMetadata(cls);
        return ident.getFirst().equals(annotation.service()) && ident.getSecond().equals(annotation.name());
    }
219139
public boolean isText() {
        boolean isJson = contentType.map(contentType -> "application/json".equals(contentType)).orElse(false);
        boolean isPlainText = contentType.map(contentType -> "text/plain".equals(contentType)).orElse(false);

        return charset.isPresent() || isJson || isPlainText;
    }
244955
private static boolean containsIgnoreCase(String str, String searchStr) {
    if (str == null || searchStr == null) {
      return false;
    }
    int len = searchStr.length();
    int max = str.length() - len;
    for (int i = 0; i <= max; i++) {
      if (str.regionMatches(true, i, searchStr, 0, len)) {
        return true;
      }
    }
    return false;
  }
732501
private static boolean isSelector( StringBuilder builder ) {
        int length = builder.length();
        if( length == 0 ) {
            return false;
        }
        switch( builder.charAt( 0 ) ) { 
            case '.': // Mixin
            case '#': // Mixin
                break;
            default:
                return true;
        }
        for( int i = 1; i < length; i++ ) {
            char ch = builder.charAt( i );
            switch( ch ) {
                case '>':
                case ':':
                    return true;
            }
        }
        return false;
    }
1085959
private static boolean isDotAtomText(String str) {
		// dot-atom-text = 1*atext *("." 1*atext)
		// atext = ALPHA / DIGIT / "!" / "#" / "$" / "%" / "&" / "'" / "*" /
		// "+" / "-" / "/" / "=" / "?" / "^" / "_" / "`" / "{" / "|" / "}" / "~"

		char prev = '.';

		final int length = str.length();
		if (length == 0)
			return false;

		for (int idx = 0; idx < length; idx++) {
			char ch = str.charAt(idx);

			if (ch == '.') {
				if (prev == '.' || idx == length - 1)
					return false;
			} else {
				if (!ATEXT_CHARS.get(ch))
					return false;
			}

			prev = ch;
		}

		return true;
	}
250362
public boolean isTextContentType(String contentType) {
        if (contentType != null) {
            String lowerContentType = contentType.toLowerCase();
            for (String textContentType : this.parsableContentTypes) {
                if (lowerContentType.startsWith(textContentType)) {
                    return true;
                }
            }
        }
        return false;
    }
724599
private boolean containsNumericMatcher(String matcherExpression) {
        for (String numericMatcher : numericMatchers) {
            if (matcherExpression.contains(numericMatcher)) {
                return true;
            }
        }

        return false;
    }
1262155
public static boolean isAlphaNumeric(String in) {
		char c = 0;
		for (int i = in.length(); i > 0; i--) {
			c = in.charAt(i - 1);
			if (!Character.isLetterOrDigit(c)) {
				return false;
			}
		}
		return true;
	}
892465
@Nonnull
  public PreloadFont getOrAddEmbeddingPreloadFont (@Nonnull final IHasFontResource aFontResProvider)
  {
    ValueEnforcer.notNull (aFontResProvider, "FontResProvider");
    return getOrAddEmbeddingPreloadFont (aFontResProvider.getFontResource ());
  }
874837
def alpha_cased(text, lower=False):
    
    text = "".join(filter(
            lambda c: c.isalpha() or c == GENERIC_PROTOCOL_KEY, text))
    return text.lower() if lower else text.upper()
1021961
private FunctionDescriptor processImport(RulesTextProvider textProvider)
    {
    	log.debug("processImport");
        textProvider.getPosition();
        String fullFunctionName = "";
        String functionName = null;
        while (alpha(textProvider))
        {
            functionName =textProvider.getLastToken();
            fullFunctionName += functionName;
            if (exact(".",textProvider))
            {
                fullFunctionName += ".";
                continue;
            }
            exactOrError("(",textProvider);
        }
        FunctionDescriptor functionDescriptor = new FunctionDescriptor(functionName, fullFunctionName);
        
        List<Class<?>> args = new ArrayList<Class<?>>();
        while (true)
        {
            if (exact(")",textProvider))
            {
                break;
            }
            if (!alpha(textProvider))
            {
                throw new ParserException("Expected argument type ",textProvider);
            }
            String argumentType = textProvider.getLastToken();
            try
            {
                args.add(Class.forName(argumentType));
            }
            catch (ClassNotFoundException e)
            {
                throw new ParserException("Expected valid class but got "+argumentType+" ",textProvider);
            }
            if (!alpha(textProvider))
            {
                throw new ParserException("Expected argument name ",textProvider);
            }
            exact(",",textProvider);
        }
        functionDescriptor.setArgTypes(args);
        textProvider.addFunction(functionDescriptor);
        return functionDescriptor;
    }
796890
public static boolean hasDigit(String str)
  {
    final Pattern pattern = Pattern.compile("[0-9]");
    final Matcher matcher = pattern.matcher(str);
    while (matcher.find())
    {
      return true;
    }
    return false;
  }
309198
public static function alphanumeric ($value)
    {
        $res = preg_match('/^[0-9a-zA-Z]+$/', $value);
        if (false === $res) {
            throw new Exception("Unable to verify alphanumericy: $value");
        } elseif (0 == $res) {
            return false;
        } else {
            return true;
        }
    }