Returns true if the specified character is a digit as defined by production [88] in the XML 1.0
specification.

@param ch
The character to check.
494138
public static boolean isDigit(int ch)
   {
      return (0x0030 <= ch && ch <= 0x0039) || (0x0660 <= ch && ch <= 0x0669) || (0x06F0 <= ch && ch <= 0x06F9)
         || (0x0966 <= ch && ch <= 0x096F) || (0x09E6 <= ch && ch <= 0x09EF) || (0x0A66 <= ch && ch <= 0x0A6F)
         || (0x0AE6 <= ch && ch <= 0x0AEF) || (0x0B66 <= ch && ch <= 0x0B6F) || (0x0BE7 <= ch && ch <= 0x0BEF)
         || (0x0C66 <= ch && ch <= 0x0C6F) || (0x0CE6 <= ch && ch <= 0x0CEF) || (0x0D66 <= ch && ch <= 0x0D6F)
         || (0x0E50 <= ch && ch <= 0x0E59) || (0x0ED0 <= ch && ch <= 0x0ED9) || (0x0F20 <= ch && ch <= 0x0F29);
   }
1052931
public boolean consume(int ch){
        offset++;
        if(ch==0x0D){
            skipLF = true;
            line++;
            col = 0;
            return true;
        }else if(ch==0x0A){
            if(skipLF){
                skipLF = false;
                return false;
            }else{
                line++;
                col = 0;
                return true;
            }
        }else{
            skipLF = false;
            col++;
            return true;
        }
    }
269385
private static int toDigit(final char ch, final int index) {
        final int digit = Character.digit(ch, 16);
        if (digit == -1) {
            throw new RuntimeException("Illegal hexadecimal charcter " + ch + " at index " + index);
        }
        return digit;
    }
1347518
private static int selectStyle(char ch) {
        switch (ch) {
        case 'S':
            return SHORT;
        case 'M':
            return MEDIUM;
        case 'L':
            return LONG;
        case 'F':
            return FULL;
        case '-':
            return NONE;
        default:
            throw new IllegalArgumentException("Invalid style character: " + ch);
        }
    }
1082184
private boolean isValidCharacters(final String component, final char padding) {
		// Check the component is either all padding chars or all digit chars
		boolean paddingChars = false;
		boolean digitChars = false;
		for (int i = 0; i < component.length(); i++) {
			char chr = component.charAt(i);
			// Padding
			if (chr == padding) {
				if (digitChars) {
					return false;
				}
				paddingChars = true;
			} else if (chr >= '0' && chr <= '9') {  // Digit
				if (paddingChars) {
					return false;
				}
				digitChars = true;
			} else {
				return false;
			}
		}

		return true;
	}
156727
public final boolean isJsonAdaptable(final char ch) {
    return ch == '"' || ch == '\\' || ch == '/'
        || ch == '\b' || ch == '\f' || ch == '\n'
          || ch == '\r' || ch == '\t';
  }
1257676
protected static int toDigit(char ch, int index) throws DecoderException {
        int digit = Character.digit(ch, 16);
        if (digit == -1) {
            throw new DecoderException("Illegal hexadecimal charcter " + ch + " at index " + index);
        }
        return digit;
    }
842678
public static boolean isNameChar (char c)
    {
	// [4] NameChar ::= Letter | Digit | '.' | '_' | ':'
	//			| CombiningChar | Extender

	if (isLetter2 (c))
	    return true;
	else if (c == '>')
	    return false;
	else if (c == '.' || c == '-' || c == '_' || c == ':'
		|| isExtender (c))
	    return true;
	else
	    return false;
    }
1070426
def is_diacritic(char, strict=True):
	
	if char in chart.diacritics:
		return True

	if not strict:
		return (unicodedata.category(char) in ['Lm', 'Mn', 'Sk']) \
				and (not is_suprasegmental(char)) \
				and (not is_tie_bar(char)) \
				and (not 0xA700 <= ord(char) <= 0xA71F)

	return False
1117254
public static boolean isValidNmtoken(String nmtoken) {
    final int length = nmtoken.length();
    if (length == 0) {
      return false;
    }
    for (int i = 0; i < length; ++i) {
      char ch = nmtoken.charAt(i);
      if (!isName(ch)) {
        return false;
      }
    }
    return true;
  }
737702
private static int specialChar(char ch) {
        if ((ch > '\u0621' && ch < '\u0626') ||
            (ch == '\u0627') ||
            (ch > '\u062E' && ch < '\u0633') ||
            (ch > '\u0647' && ch < '\u064A') ||
            (ch == '\u0629')) {
            return 1;
        } else if (ch >= '\u064B' && ch<= '\u0652') {
            return 2;
        } else if (ch >= 0x0653 && ch <= 0x0655 ||
                   ch == 0x0670 ||
                   ch >= 0xFE70 && ch <= 0xFE7F) {
            return 3;
        } else {
            return 0;
        }
    }
758002
private int _countCharsStart (final char ch)
  {
    int nCount = 0;
    for (int i = 0; i < m_sValue.length (); i++)
    {
      final char c = m_sValue.charAt (i);
      if (c == ' ')
        continue;
      if (c != ch)
        break;
      nCount++;
    }
    return nCount;
  }
489810
protected function isDigit($char)
    {
        if ($char === null) {
            return false;
        }

        // Notice: ord(null) will return 0.
        // ord() does not work with utf-8 characters.
        $ascii = ord($char);

        // ASCII codes: 48 = '0', 57 = '9'
        return ($ascii >= 48 and $ascii <= 57);
    }
364637
public boolean isLabelAnnotationIntroducingCharacter(char ch) {
    char[] cutChars = labelAnnotationIntroducingCharacters();
    for (char cutChar : cutChars) {
      if (ch == cutChar) {
        return true;
      }
    }
    return false;
  }
380500
def isthaichar(ch: str) -> bool:
    
    ch_val = ord(ch)
    if ch_val >= 3584 and ch_val <= 3711:
        return True
    return False
232898
@Override
    protected boolean isTokenChar(int c) {

      if(!Character.isWhitespace(c) && searchCharacters.indexOf(c) == -1){
        return true;
      }
      return false;
    }
393443
public static boolean endsWithChar(String str, char ch) {
        if (StringUtils.isEmpty(str)) {
            return false;
        }

        return str.charAt(str.length() - 1) == ch;
    }