"Generic" JArray support

jpype/_core.py

@@ -339,6 +339,7 @@ def initializeResources():
  _jpype._type_classes[object] = _jpype._java_lang_Object
  _jpype._type_classes[_jpype.JString] = _jpype._java_lang_String
  _jpype._type_classes[_jpype.JObject] = _jpype._java_lang_Object
+ _jpype._type_classes[_jpype.JClass] = _jpype._java_lang_Class
  _jinit.runJVMInitializers()
 
  _jpype.JClass('org.jpype.JPypeKeywords').setKeywords(

jpype/_jarray.py

@@ -15,14 +15,34 @@
 # See NOTICE file for details.
 #
 # *****************************************************************************
+import abc
+import collections.abc
 import _jpype
+import typing
 from . import _jcustomizer
 
 
 __all__ = ['JArray']
 
 
-class JArray(_jpype._JObject, internal=True): # type: ignore[call-arg]
+T = typing.TypeVar('T')
+
+
+class _JArrayGeneric(collections.abc.Sequence[T]):
+
+ @abc.abstractmethod
+ def __setitem__(self, index, value):
+ ...
+
+
+if typing.TYPE_CHECKING:
+ _array_base = _JArrayGeneric
+else:
+ # NOTE: the subscript operator needs to be used in the class definition for typing
+ _array_base = {T : _jpype._JObject}
+
+
+class JArray(_array_base[T], internal=True): # type: ignore[call-arg]
  """ Creates a Java array class for a Java type of a given dimension.
 
  This serves as a base type and factory for all Java array classes.
@@ -92,6 +112,18 @@ def __new__(cls, tp, dims=1):
  def of(cls, array, dtype=None):
  return _jpype.arrayFromBuffer(array, dtype)
 
+ def __class_getitem__(cls, key):
+ if key is _jpype.JClass:
+ # explicit check for JClass
+ # _toJavaClass cannot be used
+ # passing int, float, etc is not allowed
+ key = _jpype._java_lang_Class
+ if isinstance(key, (str, _jpype._java_lang_Class)):
+ key = _jpype.JClass(key)
+ if isinstance(key, _jpype.JClass):
+ return type(key[0])
+ raise TypeError("Cannot instantiate unspecified array type")
+
 
 class _JArrayProto(object):
 
@@ -104,6 +136,10 @@ def __iter__(self):
  def __reversed__(self):
  for elem in self[::-1]:
  yield elem
+
+ def __contains__(self, item):
+ # "in" works without this but this should be more efficient
+ return _jpype.JClass("java.util.Arrays").asList(self).contains(item)
 
  def clone(self):
  """ Clone the Java array.

jpype/_jclass.py

@@ -97,6 +97,11 @@ def __new__(cls, jc, loader=None, initialize=True):
 
  # Pass to class factory to create the type
  return _jpype._getClass(jc)
+
+ @classmethod
+ def __class_getitem__(cls, index):
+ # enables JClass[1] to get a Class[]
+ return JClass("java.lang.Class")[index]
 
 
 class JInterface(_jpype._JObject, internal=True): # type: ignore[call-arg]

native/python/pyjp_class.cpp

@@ -728,8 +728,9 @@ static PyObject *PyJPClass_array(PyJPClass *self, PyObject *item)
 
  if (self->m_Class == NULL)
  {
- PyErr_Format(PyExc_TypeError, "Cannot instantiate unspecified array type");
- return NULL;
+ PyObject *res = PyObject_CallMethod((PyObject *)self, "__class_getitem__", "O", item);
+ Py_DECREF(item);
+ return res;
  }
 
  if (PyIndex_Check(item))

test/jpypetest/test_array.py

@@ -593,6 +593,7 @@ def testShortcut(self):
  # Check Objects
  self.assertEqual(JString[5].getClass(), JArray(JString)(5).getClass())
  self.assertEqual(JObject[5].getClass(), JArray(JObject)(5).getClass())
+ self.assertEqual(JClass[5].getClass(), JArray(JClass)(5).getClass())
 
  # Test multidimensional
  self.assertEqual(JDouble[5, 5].getClass(), JArray(JDouble, 2)(5).getClass())
@@ -601,3 +602,14 @@ def testShortcut(self):
  def testJArrayIndex(self):
  with self.assertRaises(TypeError):
  jpype.JArray[10]
+
+ def testJArrayGeneric(self):
+ self.assertEqual(type(JObject[0]), JArray(JObject))
+
+ def testJArrayGeneric_Init(self):
+ Arrays = JClass("java.util.Arrays")
+ self.assertTrue(Arrays.equals(JObject[0], JArray(JObject)(0)))
+
+ def testJArrayInvalidGeneric(self):
+ with self.assertRaises(TypeError):
+ jpype.JArray[object]