Returns the type of the given character.

@param paramInput
The character the type should be determined
@return type of the given character.
422709
private TokenType retrieveType(final char paramInput) {

        TokenType type;
        switch (paramInput) {
        case ',':
            type = TokenType.COMMA;
            break;
        case '(':
            type = TokenType.OPEN_BR;
            break;
        case ')':
            type = TokenType.CLOSE_BR;
            break;
        case '[':
            type = TokenType.OPEN_SQP;
            break;
        case ']':
            type = TokenType.CLOSE_SQP;
            break;
        case '@':
            type = TokenType.AT;
            break;
        case '=':
            type = TokenType.EQ;
            break;
        case '<':
        case '>':
            type = TokenType.COMP;
            break;
        case '!':
            type = TokenType.N_EQ;
            break;
        case '/':
            type = TokenType.SLASH;
            break;
        case ':':
            type = TokenType.COLON;
            break;
        case '.':
            type = TokenType.POINT;
            break;
        case '+':
            type = TokenType.PLUS;
            break;
        case '-':
            type = TokenType.MINUS;
            break;
        case '\'':
            type = TokenType.SINGLE_QUOTE;
            break;
        case '"':
            type = TokenType.DBL_QUOTE;
            break;
        case '$':
            type = TokenType.DOLLAR;
            break;
        case '?':
            type = TokenType.INTERROGATION;
            break;
        case '*':
            type = TokenType.STAR;
            break;
        case '|':
            type = TokenType.OR;
            break;
        default:
            type = TokenType.INVALID;
        }
        return type;

    }
332717
@Override
    public int propertyNameToCType(byte[]bytes, int p, int end) {
        Integer ctype = PosixBracket.PBSTableUpper.get(bytes, p, end);
        if (ctype != null) return ctype;
        throw new CharacterPropertyException(EncodingError.ERR_INVALID_CHAR_PROPERTY_NAME, bytes, p, end - p);
    }
437321
public java.lang.String getType() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.type, "submit");

    }
379002
public static String getPrimitiveObjCType(TypeMirror type) {
    return TypeUtil.isVoid(type) ? "void"
        : type.getKind().isPrimitive() ? "j" + TypeUtil.getName(type) : "id";
  }
1137394
public InputType getOutputType(InputType... inputType) throws InvalidKerasConfigurationException {
        if (inputType.length > 1)
            throw new InvalidKerasConfigurationException(
                    "Keras PReLU layer accepts only one input (received " + inputType.length + ")");
        InputType inType = inputType[0];

        // Dynamically infer input shape of PReLU layer from input type
        PReLULayer shapedLayer = (PReLULayer) this.layer;
        shapedLayer.setInputShape(inType.getShape());
        this.layer = shapedLayer;

        return this.getPReLULayer().getOutputType(-1, inputType[0]);
    }
54786
@Override
    public InputType getOutputType(InputType... inputType) throws InvalidKerasConfigurationException {
        if (inputType.length > 1)
            throw new InvalidKerasConfigurationException(
                            "Keras LRN layer accepts only one input (received " + inputType.length + ")");
        return this.getLocalResponseNormalization().getOutputType(-1, inputType[0]);
    }
866754
private void getNumerics(String input, UnicodeSet result) {
        result.clear();

        for (int utf16Offset = 0; utf16Offset < input.length();) {
            int codePoint = Character.codePointAt(input, utf16Offset);
            utf16Offset += Character.charCount(codePoint);

            // Store a representative character for each kind of decimal digit
            if (UCharacter.getType(codePoint) == UCharacterCategory.DECIMAL_DIGIT_NUMBER) {
                // Store the zero character as a representative for comparison.
                // Unicode guarantees it is codePoint - value
                result.add(codePoint - UCharacter.getNumericValue(codePoint));
            }
        }
    }
285546
private int readChar(Reader source) throws ParseException
    {
        int c;

        try {
            c = source.read();
        } catch (IOException e) {
            throw new ParseException("Failed to read input source", e);
        }

        return c;
    }
221462
public static Class getPrimitiveType(Class type) {
        if (type == int.class || type == Integer.class) {
            return int.class;
        } else if (type == long.class || type == Long.class) {
            return long.class;
        } else if (type == short.class || type == Short.class) {
            return short.class;
        } else if (type == double.class || type == Double.class) {
            return double.class;
        } else if (type == float.class || type == Float.class) {
            return float.class;
        } else if (type == char.class || type == Character.class) {
            return char.class;
        } else if (type == byte.class || type == Byte.class) {
            return byte.class;
        } else if (type == boolean.class || type == Boolean.class) {
            return boolean.class;
        }
        throw new IllegalArgumentException("Type '" + type + "' can not be converted to primitive type.");
    }
948312
public com.google.protobuf.ByteString
      getTypeHintBytes() {
    java.lang.Object ref = typeHint_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      typeHint_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
473452
private BigInteger parseCharacter(String input) {
		int pos = 1;
		char c = input.charAt(pos++);
		if (c == '\\') {
			// escape code
			switch (input.charAt(pos++)) {
			case 'b':
				c = '\b';
				break;
			case 't':
				c = '\t';
				break;
			case 'n':
				c = '\n';
				break;
			case 'f':
				c = '\f';
				break;
			case 'r':
				c = '\r';
				break;
			case '"':
				c = '\"';
				break;
			case '\'':
				c = '\'';
				break;
			case '\\':
				c = '\\';
				break;
			default:
				throw new RuntimeException("unrecognised escape character");
			}
		}
		return BigInteger.valueOf(c);
	}
529180
public static Class<?> translateFromPrimitive(Class<?> paramType) {

        if (paramType == int.class) {
            return Integer.class;
        } else if (paramType == char.class) {
            return Character.class;
        } else if (paramType == byte.class) {
            return Byte.class;
        } else if (paramType == long.class) {
            return Long.class;
        } else if (paramType == short.class) {
            return Short.class;
        } else if (paramType == boolean.class) {
            return Boolean.class;
        } else if (paramType == double.class) {
            return Double.class;
        } else if (paramType == float.class) {
            return Float.class;
        } else {
            return paramType;
        }
    }
583736
@Override
	public void setInput(InputStream is, String charset) {
		position = 0;
		limit = 0;
		boolean detectCharset = (charset == null);

		if (is == null) {
			throw new IllegalArgumentException();
		}

		try {
			if (detectCharset) {
				// read the four bytes looking for an indication of the encoding
				// in use
				int firstFourBytes = 0;
				while (limit < 4) {
					int i = is.read();
					if (i == -1) {
						break;
					}
					firstFourBytes = (firstFourBytes << 8) | i;
					buffer[limit++] = (char) i;
				}

				if (limit == 4) {
					switch (firstFourBytes) {
					case 0x00000FEFF: // UTF-32BE BOM
						charset = "UTF-32BE";
						limit = 0;
						break;

					case 0x0FFFE0000: // UTF-32LE BOM
						charset = "UTF-32LE";
						limit = 0;
						break;

					case 0x0000003c: // '<' in UTF-32BE
						charset = "UTF-32BE";
						buffer[0] = '<';
						limit = 1;
						break;

					case 0x03c000000: // '<' in UTF-32LE
						charset = "UTF-32LE";
						buffer[0] = '<';
						limit = 1;
						break;

					case 0x0003c003f: // "<?" in UTF-16BE
						charset = "UTF-16BE";
						buffer[0] = '<';
						buffer[1] = '?';
						limit = 2;
						break;

					case 0x03c003f00: // "<?" in UTF-16LE
						charset = "UTF-16LE";
						buffer[0] = '<';
						buffer[1] = '?';
						limit = 2;
						break;

					case 0x03c3f786d: // "<?xm" in ASCII etc.
						while (true) {
							int i = is.read();
							if (i == -1) {
								break;
							}
							buffer[limit++] = (char) i;
							if (i == '>') {
								String s = new String(buffer, 0, limit);
								int i0 = s.indexOf("encoding");
								if (i0 != -1) {
									while (s.charAt(i0) != '"' && s.charAt(i0) != '\'') {
										i0++;
									}
									char deli = s.charAt(i0++);
									int i1 = s.indexOf(deli, i0);
									charset = s.substring(i0, i1);
								}
								break;
							}
						}
						break;

					default:
						// handle a byte order mark followed by something other
						// than <?
						if ((firstFourBytes & 0x0ffff0000) == 0x0feff0000) {
							charset = "UTF-16BE";
							buffer[0] = (char) ((buffer[2] << 8) | buffer[3]);
							limit = 1;
						} else if ((firstFourBytes & 0x0ffff0000) == 0x0fffe0000) {
							charset = "UTF-16LE";
							buffer[0] = (char) ((buffer[3] << 8) | buffer[2]);
							limit = 1;
						} else if ((firstFourBytes & 0x0ffffff00) == 0x0efbbbf00) {
							charset = "UTF-8";
							buffer[0] = buffer[3];
							limit = 1;
						}
					}
				}
			}

			if (charset == null) {
				charset = "UTF-8";
			}

			int savedLimit = limit;
			setInput(new InputStreamReader(is, charset));
			encoding = charset;
			limit = savedLimit;

			/*
			 * Skip the optional BOM if we didn't above. This decrements limit
			 * rather than incrementing position so that <?xml version='1.0'?>
			 * is still at character 0.
			 */
			if (!detectCharset && peekCharacter() == 0xfeff) {
				limit--;
				System.arraycopy(buffer, 1, buffer, 0, limit);
			}
		} catch (Exception e) {
			throw new KriptonRuntimeException("Invalid stream or encoding: " + e, true, this.getLineNumber(), this.getColumnNumber(), getPositionDescription(), e);
		}
	}
735413
public boolean isNumeralPunctuation(final String input) {
        for (int i = 0; i < input.length(); i++) {
            if (!isNumeralPunctuation(input.charAt(i))) {
                return false;
            }
        }
        return true;
    }
170044
public char charAt( int idx )
    {
        if ( idx < 0 )
            throw new IndexOutOfBoundsException("idx{"+idx+"} < 0");
        if ( idx >= count )
            throw new IndexOutOfBoundsException("idx{"+idx+"} >= buffer.length");
        return buff[idx];
    }
879423
def get_char_type(ch):
    
    if re.match(en_p, ch):
        return 1
    elif re.match("\d+", ch):
        return 2
    elif re.match(re_han, ch):
        return 3
    else:
        return 4
865992
def char(self, c: str) -> None:
        
        if self.peek() == c:
            self.offset += 1
        else:
            raise UnexpectedInput(self, f"char '{c}'")