/** * Convert {@link Class} list to {@link IClass} list */ public static IClass[] convertToAClass(ClassHolder classHolder, Class<?>[] classes) { if (classes == null) { return new IClass[0]; } IClass[] types = new IClass[classes.length]; for (int i = 0; i < classes.length; i++) { types[i] = classHolder.getType(classes[i]); } return types; }
if (basicElementType.isPrimitive()) { superTypes = new IClass[2]; superTypes[0] = subType.getClassHolder().getType(Cloneable.class); superTypes[1] = subType.getClassHolder().getType(Serializable.class); } else { IClass[] basicElementSuperTypes = directSuperType(basicElementType); superTypes = new IClass[basicElementSuperTypes.length]; for (int i = 0; i < superTypes.length; i++) { superTypes[i] = subType.getClassHolder().getArrayType(basicElementSuperTypes[i], arrayType.getDimension()); superTypes[0] = subType.getClassHolder().getType(Cloneable.class); superTypes[1] = subType.getClassHolder().getType(Serializable.class);
/** * Get the primitive wrap type if the argument is primitive type, otherwise * return the argument self. */ public static IClass getPrimitiveWrapAClass(IClass type) { ClassHolder ch = type.getClassHolder(); if (type.equals(ch.getType(boolean.class))) { return ch.getType(Boolean.class); } else if (type.equals(ch.getType(byte.class))) { return ch.getType(Byte.class); } else if (type.equals(ch.getType(short.class))) { return ch.getType(Short.class); } else if (type.equals(ch.getType(char.class))) { return ch.getType(Character.class); } else if (type.equals(ch.getType(int.class))) { return ch.getType(Integer.class); } else if (type.equals(ch.getType(long.class))) { return ch.getType(Long.class); } else if (type.equals(ch.getType(float.class))) { return ch.getType(Float.class); } else if (type.equals(ch.getType(double.class))) { return ch.getType(Double.class); } return type; }
/** * Get the primitive type if the argument is wrap type, otherwise * return the argument self. */ public static IClass getPrimitiveAClass(IClass type) { ClassHolder ch = type.getClassHolder(); if (type.equals(ch.getType(Boolean.class))) { return ch.getType(boolean.class); } else if (type.equals(ch.getType(Byte.class))) { return ch.getType(byte.class); } else if (type.equals(ch.getType(Short.class))) { return ch.getType(short.class); } else if (type.equals(ch.getType(Character.class))) { return ch.getType(char.class); } else if (type.equals(ch.getType(Integer.class))) { return ch.getType(int.class); } else if (type.equals(ch.getType(Long.class))) { return ch.getType(long.class); } else if (type.equals(ch.getType(Float.class))) { return ch.getType(float.class); } else if (type.equals(ch.getType(Double.class))) { return ch.getType(double.class); } return type; }
/** * boolean value */ private Value(ClassHolder holder, Boolean value) { this.cls = holder.getType(boolean.class); setProperites(value); }
/** * Get {@code null} value * * @param type * @return */ public static Value getNullValue(ClassHolder holder, Class<?> type) { return getNullValue(holder.getType(type)); }
/** * char value */ private Value(ClassHolder holder, Character value) { this.cls = holder.getType(char.class); setProperites(value); }
/** * long value */ private Value(ClassHolder holder, Long value) { this.cls = holder.getType(long.class); setProperites(value); }
/** * byte value */ private Value(ClassHolder holder, Byte value) { this.cls = holder.getType(byte.class); setProperites(value); }
/** * int value */ private Value(ClassHolder holder, Integer value) { this.cls = holder.getType(int.class); setProperites(value); }
/** * short value */ private Value(ClassHolder holder, Short value) { this.cls = holder.getType(short.class); setProperites(value); }
/** * float value */ private Value(ClassHolder holder, Float value) { this.cls = holder.getType(float.class); setProperites(value); }
/** * double value */ private Value(ClassHolder holder, Double value) { this.cls = holder.getType(double.class); setProperites(value); }
/** * string value */ private Value(ClassHolder holder, String value) { this.cls = holder.getType(String.class); setProperites(value); }
@Override public boolean match(IClass type, ClassHolder holder) { return type.isChildOrEqual(holder.getType(Map.class)); }
@Override public boolean match(IClass type, ClassHolder holder) { return type.isChildOrEqual(holder.getType(Iterable.class)); }
private Value(IClass aclass) { this.cls = aclass.getClassHolder().getType(Class.class); setProperites(aclass); }
/** * <strong>4.10.1 Subtyping among Primitive Types</strong> * * <p>The following rules define the direct supertype relation among the primitive types:</p> * <ul> * <li>double >1 float</li> * <li>float >1 long</li> * <li>long >1 int</li> * <li>int >1 char</li> * <li>int >1 short</li> * <li>short >1 byte</li> * </ul> * * @param subType * @return */ public static IClass directSuperAmongPrimitiveType(IClass subType) { switch(subType.getType().getSort()) { case Type.CHAR : return subType.getClassHolder().getType(int.class); case Type.BYTE : return subType.getClassHolder().getType(short.class); case Type.SHORT : return subType.getClassHolder().getType(int.class); case Type.INT : return subType.getClassHolder().getType(long.class); case Type.FLOAT : return subType.getClassHolder().getType(double.class); case Type.LONG : return subType.getClassHolder().getType(float.class); default : return null; } }
@Override public boolean match(IClass type, ClassHolder holder) { return type.isPrimitive() || type.isChildOrEqual(holder.getType(CharSequence.class)) || IClassUtils.isPrimitiveWrapAClass(type); }
assert e != null; if (e.isChildOrEqual(e.getClassHolder( ).getType(RuntimeException.class))) { return false;