Changeset 13276 for trunk/abcl/src/org


Ignore:
Timestamp:
05/17/11 10:51:08 (10 years ago)
Author:
Mark Evenson
Message:

Untabify.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/JavaObject.java

    r12831 r13276  
    4747    public JavaObject(Object obj) {
    4848        this.obj = obj;
    49   this.intendedClass =
    50       obj != null ? Java.maybeBoxClass(obj.getClass()) : null;
     49        this.intendedClass =
     50            obj != null ? Java.maybeBoxClass(obj.getClass()) : null;
    5151    }
    5252
     
    6363     */
    6464    public JavaObject(Object obj, Class<?> intendedClass) {
    65   if(obj != null && intendedClass == null) {
    66       intendedClass = obj.getClass();
    67   }
    68   if(intendedClass != null) {
    69       intendedClass = Java.maybeBoxClass(intendedClass);
    70       if(!intendedClass.isInstance(obj)) {
    71     throw new ClassCastException(obj + " can not be cast to " + intendedClass);
    72       }
    73   }
    74   this.obj = obj;
    75   this.intendedClass = intendedClass;
     65        if(obj != null && intendedClass == null) {
     66            intendedClass = obj.getClass();
     67        }
     68        if(intendedClass != null) {
     69            intendedClass = Java.maybeBoxClass(intendedClass);
     70            if(!intendedClass.isInstance(obj)) {
     71                throw new ClassCastException(obj + " can not be cast to " + intendedClass);
     72            }
     73        }
     74        this.obj = obj;
     75        this.intendedClass = intendedClass;
    7676    }
    7777
     
    8888                return BuiltInClass.JAVA_OBJECT;
    8989        } else {
    90       return ENSURE_JAVA_CLASS.execute(new JavaObject(obj.getClass()));
     90            return ENSURE_JAVA_CLASS.execute(new JavaObject(obj.getClass()));
    9191        }
    9292    }
     
    9898        if (type == BuiltInClass.JAVA_OBJECT)
    9999            return T;
    100   LispObject cls = NIL;
    101   if(type instanceof Symbol) {
    102       cls = LispClass.findClass(type, false);
    103   }
    104   if(cls == NIL) {
    105       cls = type;
    106   }
    107   if(cls.typep(LispClass.findClass(JAVA_CLASS, false)) != NIL) {
    108       if(obj != null) {
    109     Class c = (Class) JAVA_CLASS_JCLASS.execute(cls).javaInstance();
    110     return c.isAssignableFrom(obj.getClass()) ? T : NIL;
    111       } else {
    112     return T;
    113       }
    114   } else if(cls == BuiltInClass.SEQUENCE) {
    115       //This information is replicated here from java.lisp; it is a very
    116       //specific case, not worth implementing CPL traversal in typep
    117       if(java.util.List.class.isInstance(obj) ||
    118          java.util.Set.class.isInstance(obj)) {
    119     return T;
    120       }
    121   }
     100        LispObject cls = NIL;
     101        if(type instanceof Symbol) {
     102            cls = LispClass.findClass(type, false);
     103        }
     104        if(cls == NIL) {
     105            cls = type;
     106        }
     107        if(cls.typep(LispClass.findClass(JAVA_CLASS, false)) != NIL) {
     108            if(obj != null) {
     109                Class c = (Class) JAVA_CLASS_JCLASS.execute(cls).javaInstance();
     110                return c.isAssignableFrom(obj.getClass()) ? T : NIL;
     111            } else {
     112                return T;
     113            }
     114        } else if(cls == BuiltInClass.SEQUENCE) {
     115            //This information is replicated here from java.lisp; it is a very
     116            //specific case, not worth implementing CPL traversal in typep
     117            if(java.util.List.class.isInstance(obj) ||
     118               java.util.Set.class.isInstance(obj)) {
     119                return T;
     120            }
     121        }
    122122        return super.typep(type);
    123123    }
     
    178178     */
    179179    public final static LispObject getInstance(Object obj, boolean translated) {
    180   return getInstance(obj, translated, obj != null ? obj.getClass() : null);
     180        return getInstance(obj, translated, obj != null ? obj.getClass() : null);
    181181    }
    182182
     
    263263    @Override
    264264    public Object javaInstance(Class<?> c) {
    265   if(obj == null) {
    266       if(c.isPrimitive()) {
    267     throw new NullPointerException("Cannot assign null to " + c);
    268       }
    269       return obj;
    270   } else {
    271       c = Java.maybeBoxClass(c);
    272       if (c.isAssignableFrom(intendedClass) || c.isInstance(obj)) {
     265        if(obj == null) {
     266            if(c.isPrimitive()) {
     267                throw new NullPointerException("Cannot assign null to " + c);
     268            }
     269            return obj;
     270        } else {
     271            c = Java.maybeBoxClass(c);
     272            if (c.isAssignableFrom(intendedClass) || c.isInstance(obj)) {
    273273              // XXX In the case that c.isInstance(obj) should we then
    274274              // "fix" the intendedClass field with the (presumably)
     
    280280              // primitive types relate to their boxed
    281281              // representations. 
    282     return obj;
    283       } else {
    284     return error(new TypeError(intendedClass.getName() + " is not assignable to " + c.getName()));
    285       }
    286   }
     282                return obj;
     283            } else {
     284                return error(new TypeError(intendedClass.getName() + " is not assignable to " + c.getName()));
     285            }
     286        }
    287287    }
    288288
     
    298298
    299299    public Class<?> getIntendedClass() {
    300   return intendedClass;
     300        return intendedClass;
    301301    }
    302302
     
    337337        if (obj instanceof ControlTransfer)
    338338            return obj.toString();
    339   final String s;
    340   if(obj != null) {
    341       Class<?> c = obj.getClass();
    342       StringBuilder sb
    343     = new StringBuilder(c.isArray() ? "jarray" : c.getName());
    344       sb.append(' ');
    345       String ts = obj.toString();
    346       if(ts.length() > 32) { //random value, should be chosen sensibly
    347     sb.append(ts.substring(0, 32) + "...");
    348       } else {
    349     sb.append(ts);
    350       }
    351       s = sb.toString();
    352   } else {
    353       s = "null";
    354   }
     339        final String s;
     340        if(obj != null) {
     341            Class<?> c = obj.getClass();
     342            StringBuilder sb
     343                = new StringBuilder(c.isArray() ? "jarray" : c.getName());
     344            sb.append(' ');
     345            String ts = obj.toString();
     346            if(ts.length() > 32) { //random value, should be chosen sensibly
     347                sb.append(ts.substring(0, 32) + "...");
     348            } else {
     349                sb.append(ts);
     350            }
     351            s = sb.toString();
     352        } else {
     353            s = "null";
     354        }
    355355        return unreadableString(s);
    356356    }
     
    358358    @Override
    359359    public LispObject getDescription() {
    360   return new SimpleString(describeJavaObject(this));
     360        return new SimpleString(describeJavaObject(this));
    361361    }
    362362
    363363    @Override
    364364    public LispObject getParts() {
    365   if(obj != null) {
    366       LispObject parts = NIL;
     365        if(obj != null) {
     366            LispObject parts = NIL;
    367367            parts = parts.push(new Cons("Java class",
    368368                                        new JavaObject(obj.getClass())));
     
    370370                parts = parts.push(new Cons("intendedClass", new SimpleString(intendedClass.getCanonicalName())));
    371371            }
    372       if (obj.getClass().isArray()) {
    373     int length = Array.getLength(obj);
    374     for (int i = 0; i < length; i++) {
    375         parts = parts
     372            if (obj.getClass().isArray()) {
     373                int length = Array.getLength(obj);
     374                for (int i = 0; i < length; i++) {
     375                    parts = parts
    376376                        .push(new Cons(new SimpleString(i),
    377377                                       JavaObject.getInstance(Array.get(obj, i))));
    378     }
    379       } else {
    380     parts = Symbol.NCONC.execute(parts, getInspectedFields());
    381       }
    382       return parts.nreverse();
    383   } else {
    384       return NIL;
    385   }
     378                }
     379            } else {
     380                parts = Symbol.NCONC.execute(parts, getInspectedFields());
     381            }
     382            return parts.nreverse();
     383        } else {
     384            return NIL;
     385        }
    386386    }
    387387
    388388    private LispObject getInspectedFields()
    389   {
    390   final LispObject[] acc = new LispObject[] { NIL };
    391   doClassHierarchy(obj.getClass(), new Function() {
    392     @Override
    393     public LispObject execute(LispObject arg)
    394         {
    395         //No possibility of type error - we're mapping this function
    396         //over a list of classes
    397         Class<?> c = (Class) arg.javaInstance();
    398         for(Field f : c.getDeclaredFields()) {
    399       LispObject value = NIL;
    400       try {
    401           if(!f.isAccessible()) {
    402         f.setAccessible(true);
    403           }
    404           value = JavaObject.getInstance(f.get(obj));
    405       } catch(Exception e) {}
    406       acc[0] = acc[0].push(new Cons(f.getName(), value));
    407         }
    408         return acc[0];
    409     }
    410       });
    411   return acc[0].nreverse();
     389        {
     390        final LispObject[] acc = new LispObject[] { NIL };
     391        doClassHierarchy(obj.getClass(), new Function() {
     392                @Override
     393                public LispObject execute(LispObject arg)
     394                    {
     395                    //No possibility of type error - we're mapping this function
     396                    //over a list of classes
     397                    Class<?> c = (Class) arg.javaInstance();
     398                    for(Field f : c.getDeclaredFields()) {
     399                        LispObject value = NIL;
     400                        try {
     401                            if(!f.isAccessible()) {
     402                                f.setAccessible(true);
     403                            }
     404                            value = JavaObject.getInstance(f.get(obj));
     405                        } catch(Exception e) {}
     406                        acc[0] = acc[0].push(new Cons(f.getName(), value));
     407                    }
     408                    return acc[0];
     409                }
     410            });
     411        return acc[0].nreverse();
    412412    }
    413413
     
    417417     */
    418418    private static void doClassHierarchy(Collection<Class<?>> classes,
    419           LispObject callback,
    420           Set<Class<?>> visited)
    421   {
    422   Collection<Class<?>> newClasses = new LinkedList<Class<?>>();
    423   for(Class<?> clss : classes) {
    424       if(clss == null) {
    425     continue;
    426       }
    427       if(!visited.contains(clss)) {
    428     callback.execute(JavaObject.getInstance(clss, true));
    429     visited.add(clss);
    430       }
    431       if(!visited.contains(clss.getSuperclass())) {
    432     newClasses.add(clss.getSuperclass());
    433       }
    434       for(Class<?> iface : clss.getInterfaces()) {
    435     if (!visited.contains(iface)) {
    436         newClasses.add(iface);
    437     }
    438       }
    439   }
    440   if(!newClasses.isEmpty()) {
    441       doClassHierarchy(newClasses, callback, visited);
    442   }
     419                                        LispObject callback,
     420                                        Set<Class<?>> visited)
     421        {
     422        Collection<Class<?>> newClasses = new LinkedList<Class<?>>();
     423        for(Class<?> clss : classes) {
     424            if(clss == null) {
     425                continue;
     426            }
     427            if(!visited.contains(clss)) {
     428                callback.execute(JavaObject.getInstance(clss, true));
     429                visited.add(clss);
     430            }
     431            if(!visited.contains(clss.getSuperclass())) {
     432                newClasses.add(clss.getSuperclass());
     433            }
     434            for(Class<?> iface : clss.getInterfaces()) {
     435                if (!visited.contains(iface)) {
     436                    newClasses.add(iface);
     437                }
     438            }
     439        }
     440        if(!newClasses.isEmpty()) {
     441            doClassHierarchy(newClasses, callback, visited);
     442        }
    443443    }
    444444
     
    448448     */
    449449    public static void doClassHierarchy(Class<?> clss, LispObject callback)
    450   {
    451   if (clss != null) {
    452       Set<Class<?>> visited = new HashSet<Class<?>>();
    453       Collection<Class<?>> classes = new ArrayList<Class<?>>(1);
    454       classes.add(clss);
    455       doClassHierarchy(classes, callback, visited);
    456   }
     450        {
     451        if (clss != null) {
     452            Set<Class<?>> visited = new HashSet<Class<?>>();
     453            Collection<Class<?>> classes = new ArrayList<Class<?>>(1);
     454            classes.add(clss);
     455            doClassHierarchy(classes, callback, visited);
     456        }
    457457    }
    458458
    459459    public static LispObject mapcarClassHierarchy(Class<?> clss,
    460               final LispObject fn)
    461     {
    462   final LispObject[] acc = new LispObject[] { NIL };
    463   doClassHierarchy(clss, new Function() {
    464     @Override
    465     public LispObject execute(LispObject arg)
    466         {
    467         acc[0] = acc[0].push(fn.execute(arg));
    468         return acc[0];
    469     }
    470       });
    471   return acc[0].nreverse();
     460                                                  final LispObject fn)
     461    {
     462        final LispObject[] acc = new LispObject[] { NIL };
     463        doClassHierarchy(clss, new Function() {
     464                @Override
     465                public LispObject execute(LispObject arg)
     466                    {
     467                    acc[0] = acc[0].push(fn.execute(arg));
     468                    return acc[0];
     469                }
     470            });
     471        return acc[0].nreverse();
    472472    }
    473473
    474474    public static String describeJavaObject(final JavaObject javaObject)
    475   {
    476   final Object obj = javaObject.getObject();
    477   final StringBuilder sb =
    478       new StringBuilder(javaObject.writeToString());
    479   sb.append(" is an object of type ");
    480   sb.append(Symbol.JAVA_OBJECT.writeToString());
    481   sb.append(".");
    482   sb.append(System.getProperty("line.separator"));
    483   sb.append("The wrapped Java object is ");
    484   if (obj == null) {
    485       sb.append("null.");
    486   } else {
    487       sb.append("an ");
    488       final Class c = obj.getClass();
    489       String className = c.getName();
    490       if (c.isArray()) {
    491     sb.append("array of ");
    492     if (className.startsWith("[L") && className.endsWith(";")) {
    493         className = className.substring(1, className.length() - 1);
    494         sb.append(className);
    495         sb.append(" objects");
    496     } else if (className.startsWith("[") && className.length() > 1) {
    497         char descriptor = className.charAt(1);
    498         final String type;
    499         switch (descriptor) {
    500         case 'B': type = "bytes"; break;
    501         case 'C': type = "chars"; break;
    502         case 'D': type = "doubles"; break;
    503         case 'F': type = "floats"; break;
    504         case 'I': type = "ints"; break;
    505         case 'J': type = "longs"; break;
    506         case 'S': type = "shorts"; break;
    507         case 'Z': type = "booleans"; break;
    508         default:
    509       type = "unknown type";
    510         }
    511         sb.append(type);
    512     }
    513     sb.append(" with ");
    514     final int length = java.lang.reflect.Array.getLength(obj);
    515     sb.append(length);
    516     sb.append(" element");
    517     if (length != 1)
    518         sb.append('s');
    519     sb.append('.');
    520       } else {
    521     sb.append("instance of ");
    522     sb.append(className);
    523     sb.append(':');
    524     sb.append(System.getProperty("line.separator"));
    525     sb.append("  \"");
    526     sb.append(obj.toString());
    527     sb.append('"');
    528       }
    529   }
    530   return sb.toString();
     475        {
     476        final Object obj = javaObject.getObject();
     477        final StringBuilder sb =
     478            new StringBuilder(javaObject.writeToString());
     479        sb.append(" is an object of type ");
     480        sb.append(Symbol.JAVA_OBJECT.writeToString());
     481        sb.append(".");
     482        sb.append(System.getProperty("line.separator"));
     483        sb.append("The wrapped Java object is ");
     484        if (obj == null) {
     485            sb.append("null.");
     486        } else {
     487            sb.append("an ");
     488            final Class c = obj.getClass();
     489            String className = c.getName();
     490            if (c.isArray()) {
     491                sb.append("array of ");
     492                if (className.startsWith("[L") && className.endsWith(";")) {
     493                    className = className.substring(1, className.length() - 1);
     494                    sb.append(className);
     495                    sb.append(" objects");
     496                } else if (className.startsWith("[") && className.length() > 1) {
     497                    char descriptor = className.charAt(1);
     498                    final String type;
     499                    switch (descriptor) {
     500                    case 'B': type = "bytes"; break;
     501                    case 'C': type = "chars"; break;
     502                    case 'D': type = "doubles"; break;
     503                    case 'F': type = "floats"; break;
     504                    case 'I': type = "ints"; break;
     505                    case 'J': type = "longs"; break;
     506                    case 'S': type = "shorts"; break;
     507                    case 'Z': type = "booleans"; break;
     508                    default:
     509                        type = "unknown type";
     510                    }
     511                    sb.append(type);
     512                }
     513                sb.append(" with ");
     514                final int length = java.lang.reflect.Array.getLength(obj);
     515                sb.append(length);
     516                sb.append(" element");
     517                if (length != 1)
     518                    sb.append('s');
     519                sb.append('.');
     520            } else {
     521                sb.append("instance of ");
     522                sb.append(className);
     523                sb.append(':');
     524                sb.append(System.getProperty("line.separator"));
     525                sb.append("  \"");
     526                sb.append(obj.toString());
     527                sb.append('"');
     528            }
     529        }
     530        return sb.toString();
    531531    }
    532532
     
    556556
    557557    public static LispObject registerJavaClass(Class<?> javaClass, LispObject classMetaObject) {
    558   synchronized (javaClassMap) {
    559       javaClassMap.put(javaClass, classMetaObject);
    560       return classMetaObject;
    561   }
     558        synchronized (javaClassMap) {
     559            javaClassMap.put(javaClass, classMetaObject);
     560            return classMetaObject;
     561        }
    562562    }
    563563
    564564    public static LispObject findJavaClass(Class<?> javaClass) {
    565   synchronized (javaClassMap) {
    566       LispObject c = javaClassMap.get(javaClass);
    567       if (c != null) {
    568     return c;
    569       } else {
    570     return NIL;
    571       }
    572   }
     565        synchronized (javaClassMap) {
     566            LispObject c = javaClassMap.get(javaClass);
     567            if (c != null) {
     568                return c;
     569            } else {
     570                return NIL;
     571            }
     572        }
    573573    }
    574574
    575575    private static final Primitive _FIND_JAVA_CLASS = new Primitive("%find-java-class", PACKAGE_JAVA, false, "class-name-or-class") {
    576       public LispObject execute(LispObject arg) {
    577     try {
    578         if(arg instanceof AbstractString) {
    579       return findJavaClass(Class.forName((String) arg.getStringValue()));
    580         } else {
    581       return findJavaClass((Class<?>) arg.javaInstance());
    582         }
    583     } catch (ClassNotFoundException e) {
    584         return error(new LispError("Cannot find Java class " + arg.getStringValue()));
    585     }
    586       }
    587      
    588   };
     576            public LispObject execute(LispObject arg) {
     577                try {
     578                    if(arg instanceof AbstractString) {
     579                        return findJavaClass(Class.forName((String) arg.getStringValue()));
     580                    } else {
     581                        return findJavaClass((Class<?>) arg.javaInstance());
     582                    }
     583                } catch (ClassNotFoundException e) {
     584                    return error(new LispError("Cannot find Java class " + arg.getStringValue()));
     585                }
     586            }
     587           
     588        };
    589589
    590590    private static final Primitive _REGISTER_JAVA_CLASS = new Primitive("%register-java-class", PACKAGE_JAVA, false, "jclass class-metaobject") {
    591       public LispObject execute(LispObject jclass, LispObject classMetaObject) {
    592     return registerJavaClass((Class<?>) jclass.javaInstance(), classMetaObject);
    593       }
    594      
    595   };
     591            public LispObject execute(LispObject jclass, LispObject classMetaObject) {
     592                return registerJavaClass((Class<?>) jclass.javaInstance(), classMetaObject);
     593            }
     594           
     595        };
    596596
    597597}
Note: See TracChangeset for help on using the changeset viewer.