org.python.jsr223.PyScriptEngineScope Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-slim Show documentation
Show all versions of jython-slim Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
package org.python.jsr223;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.script.Bindings;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import org.python.core.Py;
import org.python.core.PyDictionary;
import org.python.core.PyIterator;
import org.python.core.PyList;
import org.python.core.PyObject;
import org.python.core.PyString;
import org.python.core.PyType;
import org.python.core.Visitproc;
import org.python.core.Untraversable;
import org.python.expose.ExposedType;
import org.python.expose.ExposedGet;
import org.python.expose.ExposedMethod;
/**
* JSR 223 does not map well to Jython's concept of "locals" and "globals".
* Instead, SimpleScriptContext provides ENGINE_SCOPE and GLOBAL_SCOPE, each
* with its own bindings. We adapt this multi-scope object for use as both
* a local and global dictionary.
*/
@Untraversable
@ExposedType(name = "scope", isBaseType = false)
public final class PyScriptEngineScope extends PyObject {
public static final PyType TYPE = PyType.fromClass(PyScriptEngineScope.class);
private final ScriptContext context;
private final ScriptEngine engine;
PyScriptEngineScope(ScriptEngine engine, ScriptContext context) {
this.context = context;
this.engine = engine;
}
@ExposedGet(name = "context")
public PyObject pyGetContext() {
return Py.java2py(context);
}
@ExposedGet(name = "engine")
public PyObject pyGetEngine() {
return Py.java2py(engine);
}
@ExposedMethod
public PyObject scope_keys() {
PyList members = new PyList();
List scopes = context.getScopes();
for (int scope : scopes) {
Bindings bindings = context.getBindings(scope);
if (bindings == null)
continue;
for (String key : bindings.keySet())
members.append(new PyString(key));
}
members.sort();
return members;
}
// satisfy mapping and lookup
@ExposedMethod
@Override
public PyObject __getitem__(PyObject key) {
return __finditem__(key);
}
// satisfy iterable
@ExposedMethod
@Override
public PyObject __iter__() {
return new ScopeIterator(this);
}
@ExposedMethod(defaults = "Py.None")
final PyObject scope_get(PyObject keyObj, PyObject defaultObj) {
String key = keyObj.asString();
int scope = context.getAttributesScope(key);
return scope == -1 ? defaultObj : Py.java2py(context.getAttribute(key, scope));
}
@ExposedMethod
final boolean scope_has_key(PyObject key) {
return context.getAttributesScope(key.asString()) != -1;
}
@Override
public boolean __contains__(PyObject obj) {
return scope___contains__(obj);
}
@ExposedMethod
final boolean scope___contains__(PyObject obj) {
return scope_has_key(obj);
}
@ExposedMethod(defaults = "Py.None")
final PyObject scope_setdefault(PyObject keyObj, PyObject failObj) {
PyObject result;
String key = keyObj.asString();
int scope = context.getAttributesScope(key);
if (scope == -1) {
scope = ScriptContext.ENGINE_SCOPE;
context.setAttribute(key,
failObj instanceof PyType
? failObj : failObj.__tojava__(Object.class),
scope);
result = failObj;
} else {
result = Py.java2py(context.getAttribute(key, scope));
}
return result;
}
@Override
public String toString() {
return getDictionary().toString();
}
@Override
public PyObject __finditem__(PyObject key) {
return __finditem__(key.asString());
}
@Override
public PyObject __finditem__(String key) {
int scope = context.getAttributesScope(key);
if (scope == -1)
return null;
return Py.java2py(context.getAttribute(key, scope));
}
@ExposedMethod
@Override
public void __setitem__(PyObject key, PyObject value) {
__setitem__(key.asString(), value);
}
@Override
public void __setitem__(String key, PyObject value) {
int scope = context.getAttributesScope(key);
if (scope == -1)
scope = ScriptContext.ENGINE_SCOPE;
context.setAttribute(key,
value instanceof PyType ? value : value.__tojava__(Object.class),
scope);
}
@ExposedMethod
@Override
public void __delitem__(PyObject key) {
__delitem__(key.asString());
}
@Override
public void __delitem__(String key) {
int scope = context.getAttributesScope(key);
if (scope == -1)
throw Py.KeyError(key);
context.removeAttribute(key, scope);
}
private Map getMap() {
ScopeIterator iterator = new ScopeIterator(this);
Map map = new HashMap(iterator.size());
PyObject key = iterator.__iternext__();
while (key != null) {
map.put(key, __finditem__(key));
key = iterator.__iternext__();
}
return map;
}
private PyDictionary getDictionary() {
return new PyDictionary(getMap());
}
public class ScopeIterator extends PyIterator {
private int _index;
private int _size;
private PyObject _keys;
ScopeIterator(PyScriptEngineScope scope) {
_keys = scope.scope_keys();
_size = _keys.__len__();
_index = -1;
}
public int size() {
return _size;
}
@Override
public PyObject __iternext__() {
PyObject result = null;
_index++;
if (_index < size()) {
result = _keys.__getitem__(_index);
}
return result;
}
/* Traverseproc implementation */
@Override
public int traverse(Visitproc visit, Object arg) {
int retVal = super.traverse(visit, arg);
if (retVal != 0) {
return retVal;
}
return _keys != null ? visit.visit(_keys, arg) : 0;
}
@Override
public boolean refersDirectlyTo(PyObject ob) {
return ob != null && (ob == _keys || super.refersDirectlyTo(ob));
}
}
}