How to use

equals

method

in

java.lang.Class

private static int deepHashCodeElement(Object element) {
  Class<?> cl;
  if (element == null) return 0;
  cl = element.getClass().getComponentType();
  if (cl == null) return element.hashCode();
  if (!cl.isPrimitive()) return deepHashCode((Object[]) element);
  if (cl.equals(int.class)) return hashCode((int[]) element);
  if (cl.equals(char.class)) return hashCode((char[]) element);
  if (cl.equals(boolean.class)) return hashCode((boolean[]) element);
  if (cl.equals(byte.class)) return hashCode((byte[]) element);
  if (cl.equals(long.class)) return hashCode((long[]) element);
  if (cl.equals(float.class)) return hashCode((float[]) element);
  if (cl.equals(double.class)) return hashCode((double[]) element);
  return hashCode((short[]) element);
}

  private boolean isTestMethod(Method m)
  {
    org.junit.Test annotation = m.getAnnotation(org.junit.Test.class);
    return m.getParameterTypes().length == 0 && annotation != null && m.getReturnType().equals(Void.TYPE);
  }
}

private boolean isSameClass()
{
  if (!(parameters[0] instanceof Object))
    return false;
  Class<? extends Object> type= parameters[0].getClass();
  if (Proxy.isProxyClass(type))
  {
    InvocationHandler invocationHandler= Proxy.getInvocationHandler(parameters[0]);
    if (invocationHandler instanceof InvocationHandlerForLambdas)
      type= ((InvocationHandlerForLambdas) invocationHandler).returnType;
    else
      return class1.isAssignableFrom(type);
  }
  return type.equals(class1);
}

@JTranscSync
static private boolean Arrays_equals(Class<?>[] l, Class<?>[] r) {
  if (l.length != r.length) return false;
  for (int n = 0; n < l.length; n++) {
    if (!l[n].equals(r[n])) return false;
  }
  return true;
}

private Object convertResult(Class<?> type, String annotationValue) throws java.lang.ClassNotFoundException
{
  if (type.isArray())
  {
    List<Object> result= new ArrayList<>();
    Class<?> componentType= type.getComponentType();
    String[] items= annotationValue.replace("{", "").replace("}", "").split(",");
    for (String item : items)
    {
      Object convertResult= convertResult(componentType, item);
      result.add(convertResult);
    }
    return result.toArray();
  }
  else if (type.equals(Boolean.class) || type.equals(boolean.class))
    return Boolean.parseBoolean(annotationValue);
  else if (type.equals(Class.class))
    return Class.forName(annotationValue.substring(1, annotationValue.length() - 1).replace("/", "."));
  else if (type.equals(Integer.class) || type.equals(int.class))
    return Integer.parseInt(annotationValue);
  else if (type.equals(Double.class) || type.equals(double.class))
    return Double.parseDouble(annotationValue);
  else
    return annotationValue;
}

public Object[] boxParameters(Object[] args)
{
  Class<?>[] parameterTypes= getParameterTypes();
  for (int i= 0; i < parameterTypes.length; i++)
  {
    if (parameterTypes[i].isPrimitive())
    {
      ScriptHelper.put("primitiveValue", args[i], null);
      String stringValue= (String) ScriptHelper.eval("primitiveValue.toString()", this);
      if (parameterTypes[i].equals(int.class))
        args[i]= new Integer(stringValue);
      else if (parameterTypes[i].equals(long.class))
        args[i]= new Long(stringValue);
      else if (parameterTypes[i].equals(float.class))
        args[i]= new Float(stringValue);
      else if (parameterTypes[i].equals(double.class))
        args[i]= new Double(stringValue);
      else if (parameterTypes[i].equals(short.class))
        args[i]= new Short(stringValue);
      else if (parameterTypes[i].equals(char.class))
        args[i]= new Character(stringValue.charAt(0));
      else if (parameterTypes[i].equals(byte.class))
        args[i]= new Byte(stringValue);
      else if (parameterTypes[i].equals(boolean.class))
        args[i]= new Boolean(stringValue);
    }
  }
  return args;
}

if (cl1.equals(int.class)) {
  return equals((int[]) e1, (int[]) e2);
if (cl1.equals(char.class)) {
  return equals((char[]) e1, (char[]) e2);
if (cl1.equals(boolean.class)) {
  return equals((boolean[]) e1, (boolean[]) e2);
if (cl1.equals(byte.class)) {
  return equals((byte[]) e1, (byte[]) e2);
if (cl1.equals(long.class)) {
  return equals((long[]) e1, (long[]) e2);
if (cl1.equals(float.class)) {
  return equals((float[]) e1, (float[]) e2);
if (cl1.equals(double.class)) {
  return equals((double[]) e1, (double[]) e2);

/**
 * Determines if the class or interface represented by this Class object is either the same as, or is a
 * superclass or superinterface of, the class or interface represented by the specified Class parameter.
 */
public boolean isAssignableFrom(Class<?> otherClass)
{
  Class<?>[] interfaces= getInterfaces();
  if (otherClass == null)
    throw new NullPointerException();
  if (otherClass.isInterface() && Object.class.equals(this))
    return true;
  ScriptHelper.put("otherClass", otherClass, this);
  return ScriptHelper.evalBoolean("dragomeJs.isInstanceof(otherClass.$$$nativeClass___java_lang_Object, this.$$$nativeClass___java_lang_Object)", this);
}

public static Method findMethod(
  Class<?> clazz, String name, Class<?>... parameterTypes
) {
  name = name.replace("_", "_1");
  Object[] data = findMethodData(clazz, name + "__", false);
  BIG: for (int i = 0; i < data.length; i += 3) {
    String sig = ((String) data[i]).substring(name.length() + 2);
    Class<?> cls = (Class<?>) data[i + 2];
    Method tmp = INSTANCE.create(cls, name, data[i + 1], sig);
    Class<?>[] tmpParms = tmp.getParameterTypes();
    if (parameterTypes.length != tmpParms.length) {
      continue;
    }
    for (int j = 0; j < tmpParms.length; j++) {
      if (!parameterTypes[j].equals(tmpParms[j])) {
        continue BIG;
      }
    }
    return tmp;
  }
  return null;
}

public static Constructor findConstructor(
  Class<?> clazz, Class<?>... parameterTypes) {
  Object[] data = findMethodData(clazz, "cons__", true);
  BIG: for (int i = 0; i < data.length; i += 3) {
    String sig = ((String) data[i]).substring(6);
    Class<?> cls = (Class<?>) data[i + 2];
    Constructor tmp = INSTANCE.create(cls, data[i + 1], sig);
    Class<?>[] tmpParms = tmp.getParameterTypes();
    if (parameterTypes.length != tmpParms.length) {
      continue;
    }
    for (int j = 0; j < tmpParms.length; j++) {
      if (!parameterTypes[j].equals(tmpParms[j])) {
        continue BIG;
      }
    }
    return tmp;
  }
  return null;
}

if (currentReturnType.equals(Boolean.class))
  result= result instanceof Boolean ? result : (ScriptHelper.evalBoolean("result", null) ? Boolean.TRUE : Boolean.FALSE);
else if (currentReturnType.equals(Integer.class))
  result= Integer.parseInt(ScriptHelper.evalInt("result", null) + "");
else if (currentReturnType.equals(Long.class))
  result= Long.parseLong(ScriptHelper.evalInt("result", null) + "");
else if (currentReturnType.equals(Short.class))
  result= Short.parseShort(ScriptHelper.evalInt("result", null) + "");
else if (currentReturnType.equals(Float.class))
  result= Float.parseFloat(ScriptHelper.evalFloat("result", null) + "");
else if (currentReturnType.equals(Double.class))
  result= Double.parseDouble(ScriptHelper.evalDouble("result", null) + "");
else if (currentReturnType.equals(Byte.class))
  result= Byte.valueOf((byte) ScriptHelper.evalChar("result", null));
else if (currentReturnType.equals(Character.class))
  result= Character.valueOf((ScriptHelper.eval("result", null) + "").charAt(0));

public static Method findMethod(
  Class<?> clazz, String name, Class<?>... parameterTypes
) {
  name = name.replace("_", "_1");
  Object[] data = findMethodData(clazz, name + "__", false);
  BIG: for (int i = 0; i < data.length; i += 3) {
    String sig = ((String) data[i]).substring(name.length() + 2);
    Class<?> cls = (Class<?>) data[i + 2];
    Method tmp = INSTANCE.create(cls, name, data[i + 1], sig);
    Class<?>[] tmpParms = tmp.getParameterTypes();
    if (parameterTypes.length != tmpParms.length) {
      continue;
    }
    for (int j = 0; j < tmpParms.length; j++) {
      if (!parameterTypes[j].equals(tmpParms[j])) {
        continue BIG;
      }
    }
    return tmp;
  }
  return null;
}

public static Constructor findConstructor(
  Class<?> clazz, Class<?>... parameterTypes) {
  Object[] data = findMethodData(clazz, "cons__", true);
  BIG: for (int i = 0; i < data.length; i += 3) {
    String sig = ((String) data[i]).substring(6);
    Class<?> cls = (Class<?>) data[i + 2];
    Constructor tmp = INSTANCE.create(cls, data[i + 1], sig);
    Class<?>[] tmpParms = tmp.getParameterTypes();
    if (parameterTypes.length != tmpParms.length) {
      continue;
    }
    for (int j = 0; j < tmpParms.length; j++) {
      if (!parameterTypes[j].equals(tmpParms[j])) {
        continue BIG;
      }
    }
    return tmp;
  }
  return null;
}

if (elemElemClass.isPrimitive()) {
  if (boolean.class.equals(elemElemClass)) {
    sb.append(toString((boolean[]) elem));
  } else if (byte.class.equals(elemElemClass)) {
    sb.append(toString((byte[]) elem));
  } else if (char.class.equals(elemElemClass)) {
    sb.append(toString((char[]) elem));
  } else if (double.class.equals(elemElemClass)) {
    sb.append(toString((double[]) elem));
  } else if (float.class.equals(elemElemClass)) {
    sb.append(toString((float[]) elem));
  } else if (int.class.equals(elemElemClass)) {
    sb.append(toString((int[]) elem));
  } else if (long.class.equals(elemElemClass)) {
    sb.append(toString((long[]) elem));
  } else if (short.class.equals(elemElemClass)) {
    sb.append(toString((short[]) elem));
  } else {

if (type.equals(Integer.class))
  return ScriptHelper.eval("intValue", null);
else if (type.equals(Boolean.class))
  return ScriptHelper.eval("booleanValue", null);
else if (type.equals(Long.class))
  return ScriptHelper.eval("longValue", null);
else if (type.equals(Short.class))
  return ScriptHelper.eval("shortValue", null);
else if (type.equals(Byte.class))
  return ScriptHelper.eval("byteValue", null);
else if (type.equals(Float.class))
  return ScriptHelper.eval("floatValue", null);
else if (type.equals(Double.class))
else if (type.equals(Character.class))

public static <A extends Annotation> A getAnnotationInternal(Class<?> aClass, Class<A> annotationClass, String methodName, Integer parameterIndex, String fieldName)
{
  List<AnnotationEntry> annotationEntries= new ArrayList<>(AnnotationsHelper.getAnnotationsByType(annotationClass).getEntries());
  boolean annotationFound= false;
  for (AnnotationEntry annotationEntry : annotationEntries)
    if (annotationEntry.getType().equals(aClass))
    {
      String annotationKey= AnnotationInvocationHandler.getAnnotationKey(fieldName, parameterIndex, methodName, "");
      if (annotationEntry.getAnnotationKey().startsWith(annotationKey) || (annotationKey == null && !annotationEntry.getAnnotationKey().contains("/")))
        annotationFound= true;
    }
  if (!annotationFound)
    return null;
  A annotation= (A) Proxy.newProxyInstance(null, new Class[] { annotationClass }, new AnnotationInvocationHandler(aClass, annotationClass, methodName, parameterIndex, fieldName));
  return annotation;
}

public Object invoke(Object proxy, Method method, Object[] args) throws java.lang.ClassNotFoundException
{
  ScriptHelper.put("method", method, this);
  String name= method.getName();
  if (name.equals("toString"))
  {
    return clazz.toString();
  }
  else if (name.equals("annotationType"))
  {
    return annotationClass;
  }
  else
  {
    List<AnnotationEntry> annotationEntries= new ArrayList<>(AnnotationsHelper.getAnnotationsByType(annotationClass).getEntries());
    for (AnnotationEntry annotationEntry : annotationEntries)
    {
      String key= getAnnotationKey(fieldName, parameterIndex, methodName, name);
      if (annotationEntry.getType().equals(clazz) && annotationEntry.getAnnotationKey().startsWith(key))
      {
        java.lang.String annotationValue= annotationEntry.getAnnotationValue();
        return convertResult(method.getReturnType(), annotationValue);
      }
    }
    String result= (String) ScriptHelper.eval("this.$$$annotationClass___java_lang_Class.$$$nativeClass___java_lang_Object.$$members[method.$$$signature___java_lang_String].apply()", this);
    return convertResult(method.getReturnType(), result);
  }
}