/** * 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; }
/** * 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); }
private static Value value(ClassHolder holder, Object obj) { if (obj == null) { throw new NullPointerException( "Cannot support null value for this method, use getNullValue method to get null value if you want get null!"); } if (obj instanceof Integer) { return new Value(holder, (Integer) obj); } else if (obj instanceof Short) { return new Value(holder, (Short) obj); } else if (obj instanceof Byte) { return new Value(holder, (Byte) obj); } else if (obj instanceof Boolean) { return new Value(holder, (Boolean) obj); } else if (obj instanceof Long) { return new Value(holder, (Long) obj); } else if (obj instanceof Double) { return new Value(holder, (Double) obj); } else if (obj instanceof Character) { return new Value(holder, (Character) obj); } else if (obj instanceof Float) { return new Value(holder, (Float) obj); } else if (obj instanceof IClass) { return new Value((IClass) obj); } else if (obj instanceof String) { return new Value(holder, (String) obj); } else if (obj instanceof Class) { return new Value(holder.getType((Class<?>) obj)); } throw new ASMSupportException("Cannot support type " + obj.getClass() + " for this method!"); }
/** * according the passed type list, to figure out the finally result type */ public static IClass getArithmeticalResultType(IClass... types) { IClass resultType = null; for (IClass type : types) { type = getPrimitiveAClass(type); if (isArithmetical(type)) { int typeSort = type.getType().getSort(); if (resultType == null || typeSort > resultType.getType().getSort()) { if (typeSort <= Type.INT) { resultType = type.getClassHolder().getType(int.class); } else { resultType = type; } } } else { throw new ASMSupportException(type + " dons't support arithmetical operator."); } } return resultType; }