javax.lang.model.type.PrimitiveType#getKind ( )源码实例Demo

@Override
public Class<?> visitPrimitive(PrimitiveType t, Void p) {
  switch (t.getKind()) {
    case BOOLEAN:
      return PrimitiveBooleanWrapper.class;
    case BYTE:
      return PrimitiveByteWrapper.class;
    case SHORT:
      return PrimitiveShortWrapper.class;
    case INT:
      return PrimitiveIntWrapper.class;
    case LONG:
      return PrimitiveLongWrapper.class;
    case FLOAT:
      return PrimitiveFloatWrapper.class;
    case DOUBLE:
      return PrimitiveDoubleWrapper.class;
    case CHAR:
      return null;
    default:
      return assertUnreachable();
  }
}
 

@Override
public Boolean visitPrimitive(PrimitiveType type, Void p) {
  switch (type.getKind()) {
    case BOOLEAN:
      return clazz.equals(Boolean.TYPE);
    case BYTE:
      return clazz.equals(Byte.TYPE);
    case CHAR:
      return clazz.equals(Character.TYPE);
    case DOUBLE:
      return clazz.equals(Double.TYPE);
    case FLOAT:
      return clazz.equals(Float.TYPE);
    case INT:
      return clazz.equals(Integer.TYPE);
    case LONG:
      return clazz.equals(Long.TYPE);
    case SHORT:
      return clazz.equals(Short.TYPE);
    default:
      throw new IllegalArgumentException(type + " cannot be represented as a Class<?>.");
  }
}
 

private static boolean isSameType(CompilationContext info, final Node paramNode, final VariableElement param) {
    TypeKind paramKind = param.asType().getKind();
    if (!paramKind.isPrimitive()) {
        // try unboxing
        try {
            PrimitiveType unboxedType = info.info().getTypes().unboxedType(param.asType());
            paramKind = unboxedType.getKind();
        } catch (IllegalArgumentException iae) {
            // not unboxable (isn't there a way to check this before trying to unbox??)
        }

    }
    if (TYPES.containsKey(paramNode.getClass())) {
        return TYPES.get(paramNode.getClass()).contains(paramKind);
    }
    if (paramNode instanceof AstString) {
        CharSequence typeName = info.info().getTypeUtilities().getTypeName(param.asType(), TypeNameOptions.PRINT_FQN);
        if (String.class.getName().contentEquals(typeName)) {
            return true;
        }
        if (paramKind == TypeKind.DECLARED) {
            return isSubtypeOf(info, param.asType(), "java.lang.Enum"); // NOI18N
        }
        return false;
    }
    // the ast param is an object whose real type we don't know
    // would need to further type inference for more exact matching
    return true;

}
 

/**
 * Returns one of {@link IntUnaryOperator}, {@link LongUnaryOperator} or
 * {@link DoubleUnaryOperator}, depending on {@code type}.
 *
 * @throws IllegalArgumentException if {@code type} is not one of int, long or double
 */
public static FunctionalType primitiveUnaryOperator(PrimitiveType type) {
  switch (type.getKind()) {
    case INT:
      return new FunctionalType(
          Type.from(IntUnaryOperator.class),
          "applyAsInt",
          ImmutableList.of(type),
          type);

    case LONG:
      return new FunctionalType(
          Type.from(LongUnaryOperator.class),
          "applyAsLong",
          ImmutableList.of(type),
          type);

    case DOUBLE:
      return new FunctionalType(
          Type.from(DoubleUnaryOperator.class),
          "applyAsDouble",
          ImmutableList.of(type),
          type);

    default:
      throw new IllegalArgumentException("No primitive unary operator exists for " + type);
  }
}
 

private TypeKind getPrimitiveKind(TypeMirror t) {
  if (t == null) {
    return null;
  }
  if (t.getKind().isPrimitive()) {
    return t.getKind();
  }
  PrimitiveType p = typeUtil.unboxedType(t);
  return p != null ? p.getKind() : null;
}
 

@Override
public Void visitPrimitive(PrimitiveType t, StringBuilderAndState<TypeMirror> state) {
    switch (t.getKind()) {
    case BOOLEAN:
        state.bld.append("boolean");
        break;
    case BYTE:
        state.bld.append("byte");
        break;
    case CHAR:
        state.bld.append("char");
        break;
    case DOUBLE:
        state.bld.append("double");
        break;
    case FLOAT:
        state.bld.append("float");
        break;
    case INT:
        state.bld.append("int");
        break;
    case LONG:
        state.bld.append("long");
        break;
    case SHORT:
        state.bld.append("short");
        break;
    default:
        break;
    }

    return null;
}
 

@Override
protected Void doVisitPrimitive(PrimitiveType t, StringBuilderAndState<TypeMirror> state) {
    switch (t.getKind()) {
    case BOOLEAN:
        state.bld.append("boolean");
        break;
    case BYTE:
        state.bld.append("byte");
        break;
    case CHAR:
        state.bld.append("char");
        break;
    case DOUBLE:
        state.bld.append("double");
        break;
    case FLOAT:
        state.bld.append("float");
        break;
    case INT:
        state.bld.append("int");
        break;
    case LONG:
        state.bld.append("long");
        break;
    case SHORT:
        state.bld.append("short");
        break;
    default:
        break;
    }

    return null;
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

public PrimitiveTypeMoniker(PrimitiveType type) {
    kind = type.getKind();
}
 

@Override
public boolean matches(PrimitiveType type) {
  return type.getKind() == TypeKind.INT;
}
 

@Override
public boolean matches(PrimitiveType type) {
  return type.getKind() == TypeKind.LONG;
}
 

@Override
public boolean matches(PrimitiveType type) {
  return type.getKind() == TypeKind.BYTE;
}
 

@Override
public boolean matches(PrimitiveType type) {
  return type.getKind() == TypeKind.BOOLEAN;
}
 

@Override
public boolean matches(PrimitiveType type) {
  return type.getKind() == TypeKind.DOUBLE;
}