Changes between Version 6 and Version 7 of JavaFfi/RuntimeClass


Ignore:
Timestamp:
07/09/12 21:16:24 (8 years ago)
Author:
Alessiostalla
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • JavaFfi/RuntimeClass

    v6 v7  
    6868 * if ```override``` is ```nil``` (the default), you cannot call the superclass method.
    6969 * if ```override``` is non-```nil```, a private method called ```super$```''```<the name of your method>```'' will be defined, with the following behaviour:
    70   * if ```override``` is ```T```, then the ```super$...``` method will call a method with the exact same signature as yours and defined in the direct superclass. '''Note:''' a smarter implementation could be provided that, when possible, would search in all the superclasses for the best match, according to the rules in the JLS, but it is not implemented at the moment.
     70  * if it is ```T```, then the ```super$...``` method will call a method with the exact same signature as yours and defined in the direct superclass. '''Note:''' a smarter implementation could be provided that, when possible, would search in all the superclasses for the best match, according to the rules in the JLS, but it is not implemented at the moment.
    7171  * ('''not yet implemented''') else, it is assumed to be a list in the form ```(class-name argument-types)```. A call to a method with the same name, with the provided signature and defined in the specified superclass, will be generated.
    7272
    7373'''Note:''' what happens with the super$name convention if you're overriding two overloads of the same method? A naming strategy must be defined, or the user must be given the possibility to specify another name instead of super$name.
     74
     75=== Field definitions ===
     76
     77Not yet implemented.
     78
     79=== Constructors ===
     80
     81('''not yet implemented''') The policy is to define a matching constructor for each constructor in the superclass. A constructor cannot contain direct calls to Lisp code because of the restrictions on the bytecode that can be present in the body of a constructor. However, you can optionally ('''how?''') specify an "init method" to be invoked by each constructor after calling the corresponding superclass constructor.
     82
     83The feature in the old runtime-class implementation to choose how to pass parameters to parent constructors has been deemed not sufficiently useful to warrant reimplementation.
     84
     85=== Annotation definitions ===
     86
     87An annotation definition is either:
     88
     89 * a list ```(annotation-type &rest args)```, or
     90 * a string ```annotation-type```, which is equivalent to the list ```(annotation-type)```.
     91
     92Each argument is in the form ```(arg-name &key value enum)```. ```arg-name``` can be omitted, in that case the name of the argument is "value".
     93
     94```value``` can be:
     95
     96 * an immediate value (of type boolean, fixnum, float, or string)
     97 * a list of values, for arguments of an array type
     98 * if ```enum``` is not nil, ```value``` is a string naming one of the enum constants. ```enum``` must then name a Java enumeration class.