jdk8-mips64-public/nashorn: src/jdk/nashorn/api/scripting/ScriptObjectMirror.java@80447df16322 (annotated)

src/jdk/nashorn/api/scripting/ScriptObjectMirror.java@80447df16322 (annotated)

src/jdk/nashorn/api/scripting/ScriptObjectMirror.java

Wed, 16 Jan 2013 17:58:51 +0530

author: sundar
date: Wed, 16 Jan 2013 17:58:51 +0530
changeset 33: 80447df16322
parent 7: 5a1b0714df0e
child 38: c887baec012a
permissions: -rw-r--r--

8006412: Improve toString method of ScriptObjectMirror class
Reviewed-by: jlaskey, lagergren

 /*
  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package jdk.nashorn.api.scripting;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import jdk.nashorn.internal.runtime.Context;
 import jdk.nashorn.internal.runtime.ScriptFunction;
 import jdk.nashorn.internal.runtime.ScriptObject;
 import jdk.nashorn.internal.runtime.ScriptRuntime;
 import netscape.javascript.JSObject;
 /**
  * Mirror object that wraps a given ScriptObject instance. User can
  * access ScriptObject via the java.util.Map interface.
  */
 final class ScriptObjectMirror extends JSObject implements Map<Object, Object> {
     private final ScriptObject sobj;
     private final ScriptObject global;
     ScriptObjectMirror(final ScriptObject sobj, final ScriptObject global) {
         this.sobj = sobj;
         this.global = global;
     }
     @Override
     public boolean equals(final Object other) {
         if (other instanceof ScriptObjectMirror) {
             return sobj.equals(((ScriptObjectMirror)other).sobj);
         }
         return false;
     }
     @Override
     public int hashCode() {
         return sobj.hashCode();
     }
     @Override
     public String toString() {
         return inGlobal(new Callable<String>() {
             @Override
             public String call() {
                 return ScriptRuntime.safeToString(sobj);
             }
         });
     }
     private <V> V inGlobal(final Callable<V> callable) {
         final ScriptObject oldGlobal = Context.getGlobal();
         final boolean globalChanged = (oldGlobal != global);
         if (globalChanged) {
             NashornScriptEngine.setNashornGlobal(global);
         }
         try {
             return callable.call();
         } catch (final RuntimeException e) {
             throw e;
         } catch (final Exception e) {
             throw new AssertionError("Cannot happen", e);
         } finally {
             if (globalChanged) {
                 NashornScriptEngine.setNashornGlobal(oldGlobal);
             }
         }
     }
     // JSObject methods
     @Override
     public Object call(final String methodName, final Object args[]) {
         final Object val = sobj.get(methodName);
         final ScriptObject oldGlobal = Context.getGlobal();
         final boolean globalChanged = (oldGlobal != global);
         if (val instanceof ScriptFunction) {
             final Object[] modifiedArgs = unwrapArray(args, global);
             if (modifiedArgs != null) {
                 for (int i = 0; i < modifiedArgs.length; i++) {
                     final Object arg = modifiedArgs[i];
                     if (arg instanceof ScriptObject) {
                         modifiedArgs[i] = wrap(arg, oldGlobal);
                     }
                 }
             }
             try {
                 if (globalChanged) {
                     NashornScriptEngine.setNashornGlobal(global);
                 }
                 return wrap(((ScriptFunction)val).invoke(sobj, modifiedArgs), global);
             } catch (final RuntimeException | Error e) {
                 throw e;
             } catch (final Throwable t) {
                 throw new RuntimeException(t);
             } finally {
                 if (globalChanged) {
                     NashornScriptEngine.setNashornGlobal(oldGlobal);
                 }
             }
        }
        throw new RuntimeException("No such method: " + methodName);
     }
     @Override
     public Object eval(final String s) {
         return inGlobal(new Callable<Object>() {
             @Override
             public Object call() {
                 return wrap(global.getContext().eval(global, s, null, null, false), global);
             }
         });
     }
     @Override
     public Object getMember(final String name) {
         return get(name);
     }
     @Override
     public Object getSlot(final int index) {
         return get(Integer.valueOf(index));
     }
     @Override
     public void removeMember(final String name) {
         remove(name);
     }
     @Override
     public void setMember(final String name, final Object value) {
         put(name, wrap(value, Context.getGlobal()));
     }
     @Override
     public void setSlot(final int index, final Object value) {
         put(Integer.valueOf(index), wrap(value, Context.getGlobal()));
     }
     @Override
     public void clear() {
         inGlobal(new Callable<Object>() {
             @Override public Object call() {
                 sobj.clear();
                 return null;
             }});
     }
     @Override
     public boolean containsKey(final Object key) {
         return inGlobal(new Callable<Boolean>() {
             @Override public Boolean call() {
                 return sobj.containsKey(unwrap(key, global));
             }});
     }
     @Override
     public boolean containsValue(final Object value) {
         return inGlobal(new Callable<Boolean>() {
             @Override public Boolean call() {
                 return sobj.containsValue(unwrap(value, global));
             }});
     }
     @Override
     public Set<Map.Entry<Object, Object>> entrySet() {
         return inGlobal(new Callable<Set<Map.Entry<Object, Object>>>() {
             @Override public Set<Map.Entry<Object, Object>> call() {
                 final Iterator<String>               iter    = sobj.propertyIterator();
                 final Set<Map.Entry<Object, Object>> entries = new HashSet<>();
                 while (iter.hasNext()) {
                     final Object key   = wrap(iter.next(), global);
                     final Object value = wrap(sobj.get(key), global);
                     entries.add(new AbstractMap.SimpleImmutableEntry<>(key, value));
                 }
                 return Collections.unmodifiableSet(entries);
             }
         });
     }
     @Override
     public Object get(final Object key) {
         return inGlobal(new Callable<Object>() { @Override public Object call() {
             return wrap(sobj.get(key), global);
         }});
     }
     @Override
     public boolean isEmpty() {
         return inGlobal(new Callable<Boolean>() { @Override public Boolean call() {
             return sobj.isEmpty();
         }});
     }
     @Override
     public Set<Object> keySet() {
         return inGlobal(new Callable<Set<Object>>() { @Override public Set<Object> call() {
             final Iterator<String> iter   = sobj.propertyIterator();
             final Set<Object>      keySet = new HashSet<>();
             while (iter.hasNext()) {
                 keySet.add(wrap(iter.next(), global));
             }
             return Collections.unmodifiableSet(keySet);
         }});
     }
     @Override
     public Object put(final Object key, final Object value) {
         return inGlobal(new Callable<Object>() {
             @Override public Object call() {
                 return sobj.put(unwrap(key, global), unwrap(value, global));
         }});
     }
     @Override
     public void putAll(final Map<?, ?> map) {
         final boolean strict = sobj.getContext()._strict;
         inGlobal(new Callable<Object>() { @Override public Object call() {
             for (final Map.Entry<?, ?> entry : map.entrySet()) {
                 sobj.set(unwrap(entry.getKey(), global), unwrap(entry.getValue(), global), strict);
             }
             return null;
         }});
     }
     @Override
     public Object remove(final Object key) {
         return inGlobal(new Callable<Object>() {
             @Override public Object call() {
                 return wrap(sobj.remove(unwrap(key, global)), global);
             }
         });
     }
     @Override
     public int size() {
         return inGlobal(new Callable<Integer>() {
             @Override public Integer call() {
                 return sobj.size();
             }
         });
     }
     @Override
     public Collection<Object> values() {
         return inGlobal(new Callable<Collection<Object>>() { @Override public Collection<Object> call() {
             final List<Object>     values = new ArrayList<>(size());
             final Iterator<Object> iter   = sobj.valueIterator();
             while (iter.hasNext()) {
                 values.add(wrap(iter.next(), global));
             }
             return Collections.unmodifiableList(values);
         }});
     }
     static Object wrap(final Object obj, final ScriptObject homeGlobal) {
         return (obj instanceof ScriptObject) ? new ScriptObjectMirror((ScriptObject)obj, homeGlobal) : obj;
     }
     static Object unwrap(final Object obj, final ScriptObject homeGlobal) {
         if (obj instanceof ScriptObjectMirror) {
             final ScriptObjectMirror mirror = (ScriptObjectMirror)obj;
             return (mirror.global == homeGlobal)? mirror.sobj : obj;
         }
         return obj;
     }
     static Object[] wrapArray(final Object[] args, final ScriptObject homeGlobal) {
         if (args == null || args.length == 0) {
             return args;
         }
         final Object[] newArgs = new Object[args.length];
         int index = 0;
         for (final Object obj : args) {
             newArgs[index] = wrap(obj, homeGlobal);
             index++;
         }
         return newArgs;
     }
     static Object[] unwrapArray(final Object[] args, final ScriptObject homeGlobal) {
         if (args == null || args.length == 0) {
             return args;
         }
         final Object[] newArgs = new Object[args.length];
         int index = 0;
         for (final Object obj : args) {
             newArgs[index] = unwrap(obj, homeGlobal);
             index++;
         }
         return newArgs;
     }
 }

Mercurial > jdk8-mips64-public > nashorn / annotate

src/jdk/nashorn/api/scripting/ScriptObjectMirror.java@80447df16322 (annotated)

src/jdk/nashorn/api/scripting/ScriptObjectMirror.java