org.python.core.PyStringMap 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.
/*
* Copyright (c) Corporation for National Research Initiatives
* Copyright (c) Jython Developers
*/
package org.python.core;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.AbstractSet;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.python.core.AbstractDict.ValuesIter;
import org.python.core.AbstractDict.KeysIter;
import org.python.core.AbstractDict.ItemsIter;
import org.python.core.PyMapSet.PySetIter;
import org.python.expose.ExposedClassMethod;
import org.python.expose.ExposedMethod;
import org.python.expose.ExposedNew;
import org.python.expose.ExposedType;
import org.python.expose.MethodType;
import org.python.util.Generic;
/**
* Special fast dict implementation for __dict__ instances. Allows interned String keys in addition
* to PyObject unlike PyDictionary.
*/
@ExposedType(name = "stringmap", base = PyObject.class, isBaseType = false)
public class PyStringMap extends AbstractDict implements Traverseproc {
/**
* TYPE computed lazily, PyStringMap is used early in the bootstrap process and
* statically calling fromClass(PyStringMap.class) is unsafe.
*/
private static PyType lazyType;
private final ConcurrentMap table;
public ConcurrentMap getMap() {
return table;
}
public PyStringMap() {
this(4);
}
public PyStringMap(int capacity) {
super(getLazyType());
table = new ConcurrentHashMap(capacity, Generic.CHM_LOAD_FACTOR,
Generic.CHM_CONCURRENCY_LEVEL);
}
public PyStringMap(Map map) {
this(Math.max((int) (map.size() / Generic.CHM_LOAD_FACTOR) + 1,
Generic.CHM_INITIAL_CAPACITY));
table.putAll(map);
}
public PyStringMap(PyObject elements[]) {
this(elements.length);
for (int i = 0; i < elements.length; i += 2) {
__setitem__(elements[i], elements[i + 1]);
}
}
private static PyType getLazyType() {
if (lazyType == null) {
lazyType = PyType.fromClass(PyStringMap.class);
}
return lazyType;
}
@ExposedNew
final static PyObject stringmap_new(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
PyStringMap map = new PyStringMap();
map.stringmap_update(args, keywords);
return map;
}
public static PyObject fromkeys(PyObject keys) {
return fromkeys(keys, Py.None);
}
public static PyObject fromkeys(PyObject keys, PyObject value) {
return stringmap_fromkeys(TYPE, keys, value);
}
@ExposedClassMethod(defaults = "Py.None", doc = BuiltinDocs.dict_fromkeys_doc)
static PyObject stringmap_fromkeys(PyType type, PyObject keys, PyObject value) {
PyObject d = type.__call__();
for (PyObject o : keys.asIterable()) {
d.__setitem__(o, value);
}
return d;
}
@Override
public int __len__() {
return stringmap___len__();
}
@ExposedMethod(doc = BuiltinDocs.dict___len___doc)
final int stringmap___len__() {
return table.size();
}
@Override
public boolean __nonzero__() {
return table.size() != 0;
}
@Override
public PyObject __finditem__(String key) {
if (key == null) {
return null;
}
return table.get(key);
}
@Override
public PyObject __finditem__(PyObject key) {
if (key instanceof PyString) {
return __finditem__(((PyString)key).internedString());
}
return table.get(key);
}
public PyObject __getitem__(String key) {
PyObject o = __finditem__(key);
if (null == o) {
throw Py.KeyError(key);
} else {
return o;
}
}
@Override
public PyObject __getitem__(PyObject key) {
return stringmap___getitem__(key);
}
@ExposedMethod(doc = BuiltinDocs.dict___getitem___doc)
final PyObject stringmap___getitem__(PyObject key) {
if (key instanceof PyString) {
return __getitem__(((PyString)key).internedString());
} else {
PyObject o = __finditem__(key);
if (null == o) {
throw Py.KeyError(key);
} else {
return o;
}
}
}
@Override
public PyObject __iter__() {
return stringmap___iter__();
}
@ExposedMethod(doc = BuiltinDocs.dict___iter___doc)
final PyObject stringmap___iter__() {
return stringmap_iterkeys();
}
@Override
public void __setitem__(String key, PyObject value) {
if (value == null) {
table.remove(key);
} else {
table.put(key, value);
}
}
@Override
public void __setitem__(PyObject key, PyObject value) {
stringmap___setitem__(key, value);
}
@ExposedMethod(doc = BuiltinDocs.dict___setitem___doc)
final void stringmap___setitem__(PyObject key, PyObject value) {
if (value == null) {
table.remove(pyToKey(key));
} else if (key instanceof PyString) {
__setitem__(((PyString)key).internedString(), value);
} else {
table.put(key, value);
}
}
@Override
public void __delitem__(String key) {
Object ret = table.remove(key);
if (ret == null) {
throw Py.KeyError(key);
}
}
@Override
public void __delitem__(PyObject key) {
stringmap___delitem__(key);
}
@ExposedMethod(doc = BuiltinDocs.dict___delitem___doc)
final void stringmap___delitem__(PyObject key) {
if (key instanceof PyString) {
__delitem__(((PyString)key).internedString());
} else {
Object ret = table.remove(key);
if (ret == null) {
throw Py.KeyError(key);
}
}
}
/**
* Remove all items from the dictionary.
*/
public void clear() {
stringmap_clear();
}
@ExposedMethod(doc = BuiltinDocs.dict_clear_doc)
final void stringmap_clear() {
table.clear();
}
@Override
public String toString() {
return stringmap_toString();
}
@ExposedMethod(names = {"__repr__", "__str__"}, doc = BuiltinDocs.dict___str___doc)
final String stringmap_toString() {
ThreadState ts = Py.getThreadState();
if (!ts.enterRepr(this)) {
return "{...}";
}
StringBuilder buf = new StringBuilder("{");
for (Entry entry : table.entrySet()) {
Object key = entry.getKey();
if (key instanceof String) {
/* This is a bit complicated, but prevents us to duplicate
PyString#__repr__ logic here. */
buf.append(new PyString((String)key).__repr__().toString());
} else {
buf.append(((PyObject)key).__repr__().toString());
}
buf.append(": ");
buf.append(entry.getValue().__repr__().toString());
buf.append(", ");
}
if (buf.length() > 1) {
buf.delete(buf.length() - 2, buf.length());
}
buf.append("}");
ts.exitRepr(this);
return buf.toString();
}
@Override
public int __cmp__(PyObject other) {
return stringmap___cmp__(other);
}
@ExposedMethod(type = MethodType.CMP, doc = BuiltinDocs.dict___cmp___doc)
final int stringmap___cmp__(PyObject other) {
if (!(other instanceof AbstractDict)) {
return -2;
}
int an = __len__();
int bn = other.__len__();
if (an < bn) {
return -1;
}
if (an > bn) {
return 1;
}
PyList akeys = keys();
PyList bkeys = ((AbstractDict) other).keys();
akeys.sort();
bkeys.sort();
for (int i = 0; i < bn; i++) {
PyObject akey = akeys.pyget(i);
PyObject bkey = bkeys.pyget(i);
int c = akey._cmp(bkey);
if (c != 0) {
return c;
}
PyObject avalue = __finditem__(akey);
PyObject bvalue = other.__finditem__(bkey);
c = avalue._cmp(bvalue);
if (c != 0) {
return c;
}
}
return 0;
}
/**
* Return true if the key exist in the dictionary.
*/
public boolean has_key(String key) {
return table.containsKey(key);
}
public boolean has_key(PyObject key) {
return stringmap_has_key(key);
}
@ExposedMethod(doc = BuiltinDocs.dict_has_key_doc)
final boolean stringmap_has_key(PyObject key) {
return table.containsKey(pyToKey(key));
}
@Override
public boolean __contains__(PyObject o) {
return stringmap___contains__(o);
}
@ExposedMethod(doc = BuiltinDocs.dict___contains___doc)
final boolean stringmap___contains__(PyObject o) {
return stringmap_has_key(o);
}
/**
* Return this[key] if the key exists in the mapping, defaultObj is returned otherwise.
*
* @param key
* the key to lookup in the mapping.
* @param defaultObj
* the value to return if the key does not exists in the mapping.
*/
public PyObject get(PyObject key, PyObject defaultObj) {
return stringmap_get(key, defaultObj);
}
@ExposedMethod(defaults = "Py.None", doc = BuiltinDocs.dict_get_doc)
final PyObject stringmap_get(PyObject key, PyObject defaultObj) {
PyObject obj = __finditem__(key);
return obj == null ? defaultObj : obj;
}
/**
* Return this[key] if the key exists in the mapping, None is returned otherwise.
*
* @param key
* the key to lookup in the mapping.
*/
public PyObject get(PyObject key) {
return stringmap_get(key, Py.None);
}
/**
* Return a shallow copy of the dictionary.
*/
public PyStringMap copy() {
return stringmap_copy();
}
@ExposedMethod(doc = BuiltinDocs.dict_copy_doc)
final PyStringMap stringmap_copy() {
return new PyStringMap(table);
}
public void update(PyObject other) {
stringmap_update(new PyObject[] {other}, Py.NoKeywords);
}
/**
* Insert all the key:value pairs from dict into this mapping.
*/
@ExposedMethod(doc = BuiltinDocs.dict_update_doc)
final void stringmap_update(PyObject[] args, String[] keywords) {
int nargs = args.length - keywords.length;
if (nargs > 1) {
throw PyBuiltinCallable.DefaultInfo.unexpectedCall(nargs, false, "update", 0, 1);
}
if (nargs == 1) {
PyObject arg = args[0];
if (arg.__findattr__("keys") != null) {
merge(arg);
} else {
mergeFromSeq(arg);
}
}
for (int i = 0; i < keywords.length; i++) {
__setitem__(keywords[i], args[nargs + i]);
}
}
/**
* Merge another PyObject that supports keys() with this
* dict.
*
* @param other a PyObject with a keys() method
*/
private void merge(PyObject other) {
if (other instanceof PyStringMap) {
table.putAll(((PyStringMap)other).table);
} else if (other instanceof PyDictionary) {
mergeFromKeys(other, ((PyDictionary)other).keys());
} else {
mergeFromKeys(other, other.invoke("keys"));
}
}
/**
* Merge another PyObject that supports keys() with this
* dict.
*
* @param other a PyObject with a keys() method
* @param override if true, the value from other is used on key-collision
*/
public void merge(PyObject other, boolean override) {
synchronized(table) {
if (override) {
merge(other);
} else {
if (other instanceof PyStringMap) {
Set> entrySet =
((PyStringMap)other).table.entrySet();
for (Map.Entry ent: entrySet) {
if (!table.containsKey(ent.getKey())) {
table.put(ent.getKey(), ent.getValue());
}
}
} else if (other instanceof PyDictionary) {
mergeFromKeys(other, ((PyDictionary)other).keys(), override);
} else {
mergeFromKeys(other, other.invoke("keys"), override);
}
}
}
}
/**
* Merge another PyObject via its keys() method
*
* @param other a PyObject with a keys() method
* @param keys the result of other's keys() method
*/
private void mergeFromKeys(PyObject other, PyObject keys) {
for (PyObject key : keys.asIterable()) {
__setitem__(key, other.__getitem__(key));
}
}
/**
* Merge another PyObject via its keys() method
*
* @param other a PyObject with a keys() method
* @param keys the result of other's keys() method
* @param override if true, the value from other is used on key-collision
*/
public void mergeFromKeys(PyObject other, PyObject keys, boolean override) {
synchronized(table) {
if (override) {
mergeFromKeys(other, keys);
} else {
for (PyObject key : keys.asIterable()) {
if (!__contains__(key)) {
__setitem__(key, other.__getitem__(key));
}
}
}
}
}
/**
* Merge any iterable object producing iterable objects of length
* 2 into this dict.
*
* @param other another PyObject
*/
private void mergeFromSeq(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("cannot convert dictionary update sequence "
+ "element #%d to a sequence", i));
}
throw pye;
}
int n;
if ((n = pair.__len__()) != 2) {
throw Py.ValueError(String.format("dictionary update sequence element #%d "
+ "has length %d; 2 is required", i, n));
}
__setitem__(pair.__getitem__(0), pair.__getitem__(1));
}
}
/**
* Merge any iterable object producing iterable objects of length
* 2 into this dict.
*
* @param other another PyObject
* @param override if true, the value from other is used on key-collision
*/
public void mergeFromSeq(PyObject other, boolean override) {
synchronized(table) {
if (override) {
mergeFromSeq(other);
} else {
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("cannot convert dictionary update sequence "
+ "element #%d to a sequence", i));
}
throw pye;
}
int n;
if ((n = pair.__len__()) != 2) {
throw Py.ValueError(String.format("dictionary update sequence element #%d "
+ "has length %d; 2 is required", i, n));
}
if (!__contains__(pair.__getitem__(0))) {
__setitem__(pair.__getitem__(0), pair.__getitem__(1));
}
}
}
}
}
/**
* Return this[key] if the key exist, otherwise insert key with a None value and return None.
*
* @param key
* the key to lookup in the mapping.
*/
public PyObject setdefault(PyObject key) {
return setdefault(key, Py.None);
}
/**
* Return this[key] if the key exist, otherwise insert key with the value of failobj and return
* failobj
*
* @param key
* the key to lookup in the mapping.
* @param failobj
* the default value to insert in the mapping if key does not already exist.
*/
public PyObject setdefault(PyObject key, PyObject failobj) {
return stringmap_setdefault(key, failobj);
}
@ExposedMethod(defaults = "Py.None", doc = BuiltinDocs.dict_setdefault_doc)
final PyObject stringmap_setdefault(PyObject key, PyObject failobj) {
Object internedKey = (key instanceof PyString) ? ((PyString)key).internedString() : key;
PyObject oldValue = table.putIfAbsent(internedKey, failobj);
return oldValue == null ? failobj : oldValue;
}
/**
* Return a random (key, value) tuple pair and remove the pair from the mapping.
*/
public PyObject popitem() {
return stringmap_popitem();
}
@ExposedMethod(doc = BuiltinDocs.dict_popitem_doc)
final PyObject stringmap_popitem() {
Iterator> it = table.entrySet().iterator();
if (!it.hasNext()) {
throw Py.KeyError("popitem(): dictionary is empty");
}
PyTuple tuple = itemTuple(it.next());
it.remove();
return tuple;
}
/* not correct - we need to determine size and remove at the same time! */
public PyObject pop(PyObject key) {
if (table.size() == 0) {
throw Py.KeyError("pop(): dictionary is empty");
}
return stringmap_pop(key, null);
}
public PyObject pop(PyObject key, PyObject failobj) {
return stringmap_pop(key, failobj);
}
@ExposedMethod(defaults = "null", doc = BuiltinDocs.dict_pop_doc)
final PyObject stringmap_pop(PyObject key, PyObject failobj) {
PyObject value = table.remove(pyToKey(key));
if (value == null) {
if (failobj == null) {
throw Py.KeyError(key);
} else {
return failobj;
}
}
return value;
}
/**
* Return a copy of the mappings list of (key, value) tuple pairs.
*/
public PyList items() {
return stringmap_items();
}
@ExposedMethod(doc = BuiltinDocs.dict_items_doc)
final PyList stringmap_items() {
return new PyList(stringmap_iteritems());
}
private PyTuple itemTuple(Entry entry) {
return new PyTuple(keyToPy(entry.getKey()), entry.getValue());
}
/**
* Return a copy of the mappings list of keys. We have to take in account that we could be
* storing String or PyObject objects
*/
public PyList keys() {
return stringmap_keys();
}
@ExposedMethod(doc = BuiltinDocs.dict_keys_doc)
final PyList stringmap_keys() {
Object[] keys = table.keySet().toArray();
PyObject[] keyArray = new PyObject[keys.length];
int i = 0;
for (Object key : keys) {
keyArray[i++] = keyToPy(key);
}
return new PyList(keyArray);
}
/**
* Return a copy of the mappings list of values.
*/
public PyList values() {
return stringmap_values();
}
@ExposedMethod(doc = BuiltinDocs.dict_values_doc)
final PyList stringmap_values() {
return new PyList(table.values());
}
/**
* return an iterator over (key, value) pairs
*/
public PyObject iteritems() {
return stringmap_iteritems();
}
@ExposedMethod(doc = BuiltinDocs.dict_iteritems_doc)
final PyObject stringmap_iteritems() {
return new StringMapItemsIter(table.entrySet());
}
/**
* return an iterator over the keys
*/
public PyObject iterkeys() {
return stringmap_iterkeys();
}
@ExposedMethod(doc = BuiltinDocs.dict_iterkeys_doc)
final PyObject stringmap_iterkeys() {
/* Python allows one to change the dict while iterating over it, including
deletion. Java does not. Can we resolve with CHM? */
return new StringMapKeysIter(table.keySet());
}
/**
* return an iterator over the values
*/
public PyObject itervalues() {
return stringmap_itervalues();
}
@ExposedMethod(doc = BuiltinDocs.dict_itervalues_doc)
final PyObject stringmap_itervalues() {
return new StringMapValuesIter(table.values());
}
@Override
public int hashCode() {
return stringmap___hash__();
}
@ExposedMethod(doc = BuiltinDocs.dict___hash___doc)
final int stringmap___hash__() {
throw Py.TypeError(String.format("unhashable type: '%.200s'", getType().fastGetName()));
}
@Override
public boolean isMappingType() {
return true;
}
@Override
public boolean isSequenceType() {
return false;
}
private class StringMapValuesIter extends ValuesIter {
public StringMapValuesIter(Collection c) {
super(c);
}
@Override
public PyObject __iternext__() {
check(table.size());
if (!iterator.hasNext()) {
return null;
}
return iterator.next();
}
}
private class StringMapKeysIter extends KeysIter