In Nashorn, there is no need to wrap classes/types in JavaScript objects. You
can work with them directly or extended them directly. As an example,
jjs> var ArrayList = Java.type("java.util.ArrayList"); // or var ArrayList =
java.util.ArrayList;
jjs> var Arrays = Java.type("java.util.Arrays");
jjs> var list = new ArrayList();
jjs> list.add("a");
true
jjs> list.add("b");
true
jjs> list.add("c");
true
jjs> list.addAll(Arrays.asList(["d", "e", "f"]));
true
jjs> list.addAll(Arrays.asList("g", "h", "i"));
true
jjs> for each(var e in list) print(e);
a
b
c
d
e
f
g
h
i
Is there a specific example of something you want to translate? We can help
you out.
Cheers,
-- Jim
On 2013-10-22, at 1:02 PM, Rick Bullotta <rick.bullo...@thingworx.com> wrote:
> In Rhino, you register custom adapters in a “wrap factory” that tells the
> script engine to use these adapters for accessing instances of those
> classes/types. What’s the analog in Nashorn? Can custom types implement
> interfaces that Nashorn will use?
>
> From: Jim Laskey (Oracle) [mailto:james.las...@oracle.com]
> Sent: Tuesday, October 22, 2013 11:52 AM
> To: Rick Bullotta
> Cc: nashorn-dev@openjdk.java.net
> Subject: Re: Docs/examples for JSAdapter
>
> In general the Nashorn docs start here.
> https://wiki.openjdk.java.net/display/Nashorn/Nashorn+Documentation, but as
> you point out, we seem to be lacking JSAdapter details. I should start an
> FAQ.
>
> From the javadoc (cd make; ant javadoc # ./dist/javadoc/index.html)
>
> · public final class NativeJSAdapter
> · extends ScriptObject
> This class is the implementation of the Nashorn-specific global object named
> JSAdapter. It can be thought of as the Proxy equivalent for JavaScript.
> NativeJSAdapter calls specially named JavaScript methods on an adaptee object
> when property access/update/call/new/delete is attempted on it. Example:
> var y = {
> __get__ : function (name) { ... }
> __has__ : function (name) { ... }
> __put__ : function (name, value) {...}
> __call__ : function (name, arg1, arg2) {...}
> __new__ : function (arg1, arg2) {...}
> __delete__ : function (name) { ... }
> __getIds__ : function () { ... }
> };
>
> var x = new JSAdapter(y);
>
> x.i; // calls y.__get__
> x.foo(); // calls y.__call__
> new x(); // calls y.__new__
> i in x; // calls y.__has__
> x.p = 10; // calls y.__put__
> delete x.p; // calls y.__delete__
> for (i in x) { print(i); } // calls y.__getIds__
>
> JavaScript caller of adapter object is isolated from the fact that the
> property access/mutation/deletion are really calls to JavaScript methods on
> adaptee.
>
> JSAdapter constructor can optionally receive an "overrides" object.
> Properties of overrides object is copied to JSAdapter instance. When user
> accessed property is one of these, then adaptee's methods like __get__,
> __put__ etc. are not called for those. This can be used to make certain
> "preferred" properties that can be accessed in the usual/faster way avoiding
> proxy mechanism. Example:
>
> var x = new JSAdapter({ foo: 444, bar: 6546 }) {
> __get__: function(name) { return name; }
> };
>
> x.foo; // 444 directly retrieved without __get__ call
> x.bar = 'hello'; // "bar" directly set without __put__ call
> x.prop // calls __get__("prop") as 'prop' is not overridden
>
> It is possible to pass a specific prototype for JSAdapter instance by passing
> three arguments to JSAdapter constructor. So exact signature of JSAdapter
> constructor is as follows:
> JSAdapter([proto], [overrides], adaptee);
>
> Both proto and overrides are optional - but adaptee is not. When proto is not
> passed JSAdapter.prototype is used.
> ·
>
> As well as the test ./test/script/basic/jsadapter.js
>
> var obj = new JSAdapter() {
> __get__: function(name) {
> print("getter called for '" + name + "'"); return name;
> },
>
> __put__: function(name, value) {
> print("setter called for '" + name + "' with " + value);
> },
>
> __call__: function(name, arg1, arg2) {
> print("method '" + name + "' called with " + arg1 + ", " + arg2);
> },
>
> __new__: function(arg1, arg2) {
> print("new with " + arg1 + ", " + arg2);
> },
>
> __getIds__: function() {
> print("__getIds__ called");
> return [ "foo", "bar" ];
> },
>
> __getValues__: function() {
> print("__getValues__ called");
> return [ "fooval", "barval" ];
> },
>
> __has__: function(name) {
> print("__has__ called with '" + name + "'");
> return name == "js";
> },
>
> __delete__: function(name) {
> print("__delete__ called with '" + name + "'");
> return true;
> }
> };
>
> // calls __get__
> print(obj.foo);
>
> // calls __put__
> obj.foo = 33;
>
> // calls __call__
> obj.func("hello", "world");
>
> // calls __new__
> new obj("hey!", "it works!");
>
> for (i in obj) {
> print(i);
> }
>
> for each (i in obj) {
> print(i);
> }
>
> var x = "foo" in obj;
> print(x);
>
> var y = "js" in obj;
> print(y);
>
> print(delete obj.prop);
>
> print(obj["js"]);
> obj["js"] = "javascript";
> print(obj["javascript"]);
>
> Hope that helps. Is there a specific question?
>
> Cheers,
>
> -- Jim
>
> On 2013-10-22, at 11:50 AM, Rick Bullotta <rick.bullo...@thingworx.com> wrote:
>
>
> Hi, all.
>
> I've been searching everywhere for any form of documentation or substantive
> examples as to how JSAdapter works in Nashorn, as it is an essential piece of
> the puzzle for many of us who will naturally be migrating from Rhino.
>
> Can anyone provide and additional info?
>
> Thanks,
>
> Rick
> ThingWorx
>
>
