@Untraversable

private static class MapMethod extends PyBuiltinMethodNarrow {

protected MapMethod(String name, int numArgs) {

super(name, numArgs);

}

protected MapMethod(String name, int minArgs, int maxArgs) {

super(name, minArgs, maxArgs);

}

protected Map<Object, Object> asMap() {

return (Map<Object, Object>) self.getJavaProxy();

}

}

@Untraversable

private static class MapClassMethod extends PyBuiltinClassMethodNarrow {

protected MapClassMethod(String name, int minArgs, int maxArgs) {

super(name, minArgs, maxArgs);

}

protected Class<?> asClass() {

return (Class<?>) self.getJavaProxy();

}

}

/**

private static PyBoolean mapEq(PyObject self, PyObject other) {

if (isPyDict(other)) {

// Being compared to Python dict

PyDictionary oDict = (PyDictionary) other;

Map<Object, Object> selfMap = (Map<Object, Object>) self.getJavaProxy();

if (selfMap.size() != oDict.size()) {

// Map/dict are different sizes therefore not equal

return Py.False;

}

// Loop through all entries checking the keys and values are matched

for (Entry<Object, Object> entry : selfMap.entrySet()) {

Object k = entry.getKey();

Object v = entry.getValue();

PyObject oVal = oDict.__finditem__(Py.java2py(k));

if (oVal == null) {

// No value for this key in oDict, therefore not equal

return Py.False;

}

if (!Py.java2py(v)._eq(oVal).__nonzero__()) {

// The values for this key differ therefore not equal

return Py.False;

}

}

// All keys and values are equal therefore map/dict are equal

return Py.True;

} else {

// Being compared to something that is not a Python dict

Object oj = other.getJavaProxy();

if (oj instanceof Map) {

// Being compared to a Java Map convert to Python

Map<Object, Object> map = (Map) oj;

final Map<PyObject, PyObject> pyMap = new HashMap<>();

for (Entry<Object, Object> el : map.entrySet()) {

pyMap.put(Py.java2py(el.getKey()), Py.java2py(el.getValue()));

}

// Compare again this time after conversion to Python dict

return mapEq(self, new PyDictionary(pyMap));

} else {

/*

return null;

}

}

}

private static boolean isPyDict(PyObject object) {

return object.getType().isSubType(PyDictionary.TYPE);

}

/**

private static Object tojava(PyObject pyo) {

return (pyo == null || pyo == Py.None) ? null : Py.tojava(pyo, Object.class);

}

/** Return Python {@code ValueError} that None is not allowed. */

private static RuntimeException nullException() {

return Py.ValueError("None is not allowed: underlying container cannot store Java null.");

}

/**

private static RuntimeException nullException(NullPointerException npe, Object key,

Object value) {

return (key == Py.None || value == Py.None) ? nullException() : npe;

}

/*

private static PyObject mapLe(PyObject self, PyObject other) {

Set<Object> selfKeys = ((Map<Object, Object>) self.getJavaProxy()).keySet();

if (other.getType().isSubType(PyDictionary.TYPE)) {

PyDictionary oDict = (PyDictionary) other;

for (Object k : selfKeys) {

if (!oDict.__contains__(Py.java2py(k))) {

return Py.False;

}

}

return Py.True;

} else {

Object oj = other.getJavaProxy();

if (oj instanceof Map) {

Map<Object, Object> map = (Map<Object, Object>) oj;

return Py.newBoolean(map.keySet().containsAll(selfKeys));

} else {

return null;

}

}

}

// Map doesn't extend Collection, so it needs its own version of len, iter and contains

private static final PyBuiltinMethodNarrow mapLenProxy = new MapMethod("__len__", 0) {

@Override

public PyObject __call__() {

return Py.java2py(asMap().size());

}

};

private static final PyBuiltinMethodNarrow mapReprProxy = new MapMethod("__repr__", 0) {

@Override

public PyObject __call__() {

ThreadState ts = Py.getThreadState();

if (!ts.enterRepr(self)) {

return Py.newString("{...}");

} else {

StringBuilder repr = new StringBuilder("{");

boolean first = true;

for (Map.Entry<Object, Object> entry : asMap().entrySet()) {

if (first) {

first = false;

} else {

repr.append(", ");

}

PyObject key = Py.java2py(entry.getKey());

repr.append(key.__repr__().toString());

repr.append(": ");

PyObject value = Py.java2py(entry.getValue());

repr.append(value.__repr__().toString());

}

repr.append("}");

ts.exitRepr(self);

return Py.newString(repr.toString());

}

}

};

private static final PyBuiltinMethodNarrow mapEqProxy = new MapMethod("__eq__", 1) {

@Override

public PyObject __call__(PyObject other) {

return mapEq(self, other);

}

};

private static final PyBuiltinMethodNarrow mapNeProxy = new MapMethod("__ne__", 1) {

@Override

public PyObject __call__(PyObject other) {

// mapEq may return null if we don't know how to compare to other.

PyBoolean equal = mapEq(self, other);

if (equal != null) {

// implement NOT equal by the inverse of equal

return equal.__not__();

}

return null;

}

};

private static final PyBuiltinMethodNarrow mapLeProxy = new MapMethod("__le__", 1) {

@Override

public PyObject __call__(PyObject other) {

return mapLe(self, other);

}

};

private static final PyBuiltinMethodNarrow mapGeProxy = new MapMethod("__ge__", 1) {

@Override

public PyObject __call__(PyObject other) {

return (mapLe(self, other).__not__()).__or__(mapEq(self, other));

}

};

private static final PyBuiltinMethodNarrow mapLtProxy = new MapMethod("__lt__", 1) {

@Override

public PyObject __call__(PyObject other) {

return mapLe(self, other).__and__(mapEq(self, other).__not__());

}

};

private static final PyBuiltinMethodNarrow mapGtProxy = new MapMethod("__gt__", 1) {

@Override

public PyObject __call__(PyObject other) {

return mapLe(self, other).__not__();

}

};

private static final PyBuiltinMethodNarrow mapIterProxy = new MapMethod("__iter__", 0) {

@Override

public PyObject __call__() {

return new JavaIterator(asMap().keySet());

}

};

private static final PyBuiltinMethodNarrow mapContainsProxy = new MapMethod("__contains__", 1) {

@Override

public PyObject __call__(PyObject obj) {

return asMap().containsKey(tojava(obj)) ? Py.True : Py.False;

}

};

/*

private static final PyBuiltinMethodNarrow mapGetProxy = new MapMethod("get", 1, 2) {

@Override

public PyObject __call__(PyObject key) {

return __call__(key, Py.None);

}

@Override

public PyObject __call__(PyObject key, PyObject _default) {

Map<Object, Object> map = asMap();

Object k = tojava(key);

if (map.containsKey(k)) {

return Py.java2py(map.get(k));

} else {

return _default;

}

}

};

private static final PyBuiltinMethodNarrow mapGetItemProxy = new MapMethod("__getitem__", 1) {

@Override

public PyObject __call__(PyObject key) {

Map<Object, Object> map = asMap();

Object k = tojava(key);

if (map.containsKey(k)) {

return Py.java2py(map.get(k));

}

throw Py.KeyError(key);

}

};

private static final PyBuiltinMethodNarrow mapPutProxy = new MapMethod("__setitem__", 2) {

@Override

public PyObject __call__(PyObject key, PyObject value) {

try {

asMap().put(tojava(key), tojava(value));

return Py.None;

} catch (NullPointerException npe) {

throw nullException(npe, key, value);

}

}

};

private static final PyBuiltinMethodNarrow mapRemoveProxy = new MapMethod("__delitem__", 1) {

@Override

public PyObject __call__(PyObject key) {

Map<Object, Object> map = asMap();

Object k = tojava(key);

if (map.containsKey(k)) {

map.remove(k);

return Py.None;

}

throw Py.KeyError(key);

}

};

private static final PyBuiltinMethodNarrow mapIterItemsProxy = new MapMethod("iteritems", 0) {

@Override

public PyObject __call__() {

final Iterator<Map.Entry<Object, Object>> entryIterator = asMap().entrySet().iterator();

return new PyIterator() {

@Override

public PyObject __iternext__() {

if (entryIterator.hasNext()) {

Map.Entry<Object, Object> e = entryIterator.next();

// yield a Python tuple object (key, value)

return new PyTuple(Py.java2py(e.getKey()), Py.java2py(e.getValue()));

}

return null;

}

};

}

};

private static final PyBuiltinMethodNarrow mapIterKeysProxy = new MapMethod("iterkeys", 0) {

@Override

public PyObject __call__() {

final Iterator<Object> keyIterator = asMap().keySet().iterator();

return new PyIterator() {

@Override

public PyObject __iternext__() {

if (keyIterator.hasNext()) {

Object nextKey = keyIterator.next();

// yield a Python key

return Py.java2py(nextKey);

}

return null;

}

};

}

};

private static final PyBuiltinMethodNarrow mapIterValuesProxy = new MapMethod("itervalues", 0) {

@Override

public PyObject __call__() {

final Iterator<Object> valueIterator = asMap().values().iterator();

return new PyIterator() {

@Override

public PyObject __iternext__() {

if (valueIterator.hasNext()) {

Object nextValue = valueIterator.next();

// yield a Python value

return Py.java2py(nextValue);

}

return null;

}

};

}

};

private static final PyBuiltinMethodNarrow mapHasKeyProxy = new MapMethod("has_key", 1) {

@Override

public PyObject __call__(PyObject key) {

return asMap().containsKey(tojava(key)) ? Py.True : Py.False;

}

};

private static final PyBuiltinMethodNarrow mapKeysProxy = new MapMethod("keys", 0) {

@Override

public PyObject __call__() {

PyList keys = new PyList();

for (Object key : asMap().keySet()) {

keys.add(Py.java2py(key));

}

return keys;

}

};

private static final PyBuiltinMethod mapValuesProxy = new MapMethod("values", 0) {

@Override

public PyObject __call__() {

PyList values = new PyList();

for (Object value : asMap().values()) {

values.add(Py.java2py(value));

}

return values;

}

};

private static final PyBuiltinMethodNarrow mapSetDefaultProxy =

new MapMethod("setdefault", 1, 2) {

@Override

public PyObject __call__(PyObject key) {

return __call__(key, Py.None);

}

@Override

public PyObject __call__(PyObject pykey, PyObject _default) {

Map<Object, Object> map = asMap();

Object key = tojava(pykey);

try {

if (map.containsKey(key)) {

return Py.java2py(map.get(key));

} else {

map.put(key, tojava(_default));

return _default;

}

} catch (NullPointerException npe) {

throw nullException(npe, key, _default);

}

}

};

private static final PyBuiltinMethodNarrow mapPopProxy = new MapMethod("pop", 1, 2) {

@Override

public PyObject __call__(PyObject key) {

return __call__(key, null);

}

@Override

public PyObject __call__(PyObject key, PyObject _default) {

Map<Object, Object> map = asMap();

Object k = tojava(key);

if (map.containsKey(k)) {

return Py.java2py(map.remove(k));

} else if (_default == null) {

throw Py.KeyError(key);

} else {

return _default;

}

}

};

private static final PyBuiltinMethodNarrow mapPopItemProxy = new MapMethod("popitem", 0) {

@Override

public PyObject __call__() {

Map<Object, Object> map = asMap();

Iterator<Entry<Object, Object>> entryIterator = map.entrySet().iterator();

if (entryIterator.hasNext()) {

Map.Entry<Object, Object> e = entryIterator.next();

entryIterator.remove();

return new PyTuple(Py.java2py(e.getKey()), Py.java2py(e.getValue()));

}

throw Py.KeyError("popitem(): map is empty");

}

};

private static final PyBuiltinMethodNarrow mapItemsProxy = new MapMethod("items", 0) {

@Override

public PyObject __call__() {

PyList items = new PyList();

for (Map.Entry<Object, Object> entry : asMap().entrySet()) {

items.add(new PyTuple(Py.java2py(entry.getKey()), Py.java2py(entry.getValue())));

}

return items;

}

};

private static final PyBuiltinMethodNarrow mapCopyProxy = new MapMethod("copy", 0) {

@Override

public PyObject __call__() {

Map<Object, Object> map = asMap();

Map<Object, Object> newMap;

Class<? extends Map<Object, Object>> clazz;

try {

clazz = (Class<Map<Object, Object>>) map.getClass();

Constructor<? extends Map<Object, Object>> ctor = clazz.getDeclaredConstructor();

newMap = ctor.newInstance();

for (Map.Entry<Object, Object> entry : map.entrySet()) {

newMap.put(entry.getKey(), entry.getValue());

}

} catch (NullPointerException npe) {

throw nullException();

} catch (ReflectiveOperationException | SecurityException

| IllegalArgumentException e) {

throw Py.JavaError(e);

}

return Py.java2py(newMap);

}

};

private static final PyBuiltinMethodNarrow mapUpdateProxy = new MapMethod("update", 0, 1) {

@Override

public PyObject __call__() {

return Py.None;

}

@Override

public PyObject __call__(PyObject other) {

/*

return __call__(new PyObject[] {other}, new String[] {});

}

@Override

public PyObject __call__(PyObject[] args, String[] keywords) {

// Adapted from PyDictionary#update

int nargs = args.length - keywords.length;

if (nargs > 1) {

throw PyBuiltinCallable.DefaultInfo.unexpectedCall(nargs, false, "update", 0, 1);

}

Map<Object, Object> map = asMap();

try {

if (nargs == 1) {

PyObject other = args[0];

Object proxy = other.getJavaProxy();

if (proxy instanceof Map) {

// other proxies a Java container: take contents verbatim.

map.putAll((Map<Object, Object>) proxy);

} else if (other instanceof PyDictionary) {

// keys and values must be converted from Python to Java equivalents.

mergeFromSeq(map, other.invoke("items"));

} else if (other instanceof PyStringMap) {

// keys and values must be converted from Python to Java equivalents.

mergeFromKeys(map, other, ((PyStringMap) other).keys());

} else if (other.__findattr__("keys") != null) {

// This is a dict-like object but addressed by looking up the keys.

mergeFromKeys(map, other, other.invoke("keys"));

} else {

// This should be a sequence of tuples (each an entry).

mergeFromSeq(map, other);

}

}

// update with entries from keyword arguments

for (int i = 0; i < keywords.length; i++) {

String k = keywords[i];

Object v = tojava(args[nargs + i]);

map.put(k, v);

}

} catch (NullPointerException npe) {

throw nullException();

}

return Py.None;

}

private void mergeFromKeys(Map<Object, Object> map, PyObject other, PyObject keys) {

for (PyObject key : keys.asIterable()) {

Object value = tojava(other.__getitem__(key));

map.put(tojava(key), value);

}

}

private void mergeFromSeq(Map<Object, Object> map, PyObject other) {

PyObject pairs = other.__iter__();

PyObject pair;

for (int i = 0; (pair = pairs.__iternext__()) != null; i++) {

try {

pair = PySequence.fastSequence(pair, "");

} catch (PyException pye) {

if (pye.match(Py.TypeError)) {

throw Py.TypeError(String.format(ERR_SEQ, i));

}

throw pye;

}

int n;

if ((n = pair.__len__()) != 2) {

throw Py.ValueError(String.format(ERR_LENGTH, i, n));

}

map.put(tojava(pair.__getitem__(0)), tojava(pair.__getitem__(1)));

}

}

private static final String ERR_SEQ =

"cannot convert dictionary update element #%d to a sequence";

private static final String ERR_LENGTH =

"dictionary update sequence element #%d has length %d; 2 is required";

};

private static final PyBuiltinClassMethodNarrow mapFromKeysProxy =

new MapClassMethod("fromkeys", 1, 2) {

@Override

public PyObject __call__(PyObject keys) {

return __call__(keys, null);

}

@Override

public PyObject __call__(PyObject keys, PyObject _default) {

Object defobj = tojava(_default);

Class<? extends Map<Object, Object>> clazz;

try {

clazz = (Class<Map<Object, Object>>) asClass();

Constructor<? extends Map<Object, Object>> ctor =

clazz.getDeclaredConstructor();

Map<Object, Object> theMap = ctor.newInstance();

for (PyObject key : keys.asIterable()) {

theMap.put(tojava(key), defobj);

}

return Py.java2py(theMap);

} catch (NullPointerException npe) {

throw nullException();

} catch (ReflectiveOperationException | SecurityException

| IllegalArgumentException e) {

throw Py.JavaError(e);

}

}

};

static PyBuiltinMethod[] getProxyMethods() {

//@formatter:off

return new PyBuiltinMethod[]{

mapLenProxy,

// map IterProxy can conflict with Iterable.class;

// fix after the fact in handleMroError

mapIterProxy,

mapReprProxy,

mapEqProxy,

mapNeProxy,

mapLeProxy,

mapLtProxy,

mapGeProxy,

mapGtProxy,

mapContainsProxy,

mapGetItemProxy,

mapPutProxy,

mapRemoveProxy,

mapIterItemsProxy,

mapIterKeysProxy,

mapIterValuesProxy,

mapHasKeyProxy,

mapKeysProxy,

mapSetDefaultProxy,

mapPopProxy,

mapPopItemProxy,

mapItemsProxy,

mapCopyProxy,

mapUpdateProxy,

mapFromKeysProxy // class method

};

//@formatter:on

}

static PyBuiltinMethod[] getPostProxyMethods() {

return new PyBuiltinMethod[]{

mapGetProxy,

mapValuesProxy

};

}