111 direct byte buffer support

.github/workflows/build.yml

@@ -51,20 +51,20 @@ jobs:
           - { machine: 'ubuntu-20.04', python: '3.10', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/Linux/bdist-wheel.sh' }
           - { machine: 'ubuntu-20.04', python: '3.11', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/Linux/bdist-wheel.sh' }
           - { machine: 'ubuntu-20.04', python: '3.12', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/Linux/bdist-wheel.sh' }
-          - { machine: 'windows-2022', python: '3.6',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.7',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.8',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.9',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.10', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.11', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'windows-2022', python: '3.12', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
-          - { machine: 'macos-11', python: '3.6', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.7', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.8', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.9', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.10', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.11', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
-          - { machine: 'macos-11', python: '3.12', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'windows-2022', python: '3.6',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.7',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.8',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.9',  pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.10', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.11', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'windows-2022', python: '3.12', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.\.github\env\Windows\bdist-wheel.ps1' }
+#          - { machine: 'macos-11', python: '3.6', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.7', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.8', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.9', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.10', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.11', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
+#          - { machine: 'macos-11', python: '3.12', pythonArchitecture: 'x64', arch: 'amd64', cmd: '.github/env/macOS/bdist-wheel.sh' }
           # Add M1 powered runners when available
           # https://github.com/jpy-consortium/jpy/issues/110
 
@@ -90,35 +90,36 @@ jobs:
           path: dist/*.whl
           retention-days: 1
 
-  bdist-wheels-linux-arm64:
-    runs-on: 'ubuntu-22.04'
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Bake
-        uses: docker/[email protected]
-        with:
-          files: .github/docker/docker-bake.hcl
-          pull: true
-          set: |
-            *.platform=linux/arm64/v8
-            *.output=type=local,dest=/tmp/dist
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: bdist-wheels-linux-arm64
-          path: /tmp/dist/*.whl
-          retention-days: 1
+#  bdist-wheels-linux-arm64:
+#    runs-on: 'ubuntu-22.04'
+#    steps:
+#      - uses: actions/checkout@v3
+#
+#      - name: Set up QEMU
+#        uses: docker/setup-qemu-action@v2
+#
+#      - name: Set up Docker Buildx
+#        uses: docker/setup-buildx-action@v2
+#
+#      - name: Bake
+#        uses: docker/[email protected]
+#        with:
+#          files: .github/docker/docker-bake.hcl
+#          pull: true
+#          set: |
+#            *.platform=linux/arm64/v8
+#            *.output=type=local,dest=/tmp/dist
+#
+#      - uses: actions/upload-artifact@v3
+#        with:
+#          name: bdist-wheels-linux-arm64
+#          path: /tmp/dist/*.whl
+#          retention-days: 1
 
   collect-artifacts:
     runs-on: ubuntu-22.04
-    needs: ['sdist', 'bdist-wheel', 'bdist-wheels-linux-arm64']
+#    needs: ['sdist', 'bdist-wheel', 'bdist-wheels-linux-arm64']
+    needs: ['sdist', 'bdist-wheel']
     steps:
       - uses: actions/checkout@v4
       - uses: actions/download-artifact@v3

src/main/c/jpy_conv.c

@@ -293,4 +293,3 @@ int JPy_AsJString(JNIEnv* jenv, PyObject* arg, jstring* stringRef)
 
     return 0;
 }
-

src/main/c/jpy_jbyte_buffer.c

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2023 JPY-CONSORTIUM Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "jpy_module.h"
+#include "jpy_diag.h"
+#include "jpy_jarray.h"
+#include "jpy_jbyte_buffer.h"
+
+/* 
+ * This file for now is just a place-holder for future JPy_ByteBufferWrapper specific functions.
+ */

src/main/c/jpy_jbyte_buffer.h

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2023 JPY-CONSORTIUM Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef JPY_JBYTE_BUFFER_H
+#define JPY_JBYTE_BUFFER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "jpy_compat.h"
+
+/**
+ * The Java ByteBuffer representation in Python.
+ *
+ * IMPORTANT: JPy_JByteBufferWrapper must only differ from the JPy_JObj structure by the 'pyBuffer' member
+ * since we use the same basic type, name JPy_JType for it. DON'T ever change member positions!
+ * @see JPy_JObj
+ */
+typedef struct JPy_JByteBufferWrapper
+{
+    PyObject_HEAD
+    jobject objectRef;
+    Py_buffer *pyBuffer;
+}
+JPy_JByteBufferWrapper;
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+#endif /* !JPY_JBYTE_BUFFER_H */

src/main/c/jpy_jobj.c

@@ -20,6 +20,7 @@
 #include "jpy_module.h"
 #include "jpy_diag.h"
 #include "jpy_jarray.h"
+#include "jpy_jbyte_buffer.h"
 #include "jpy_jtype.h"
 #include "jpy_jobj.h"
 #include "jpy_jmethod.h"
@@ -56,16 +57,24 @@ PyObject* JObj_FromType(JNIEnv* jenv, JPy_JType* type, jobject objectRef)
 
     obj->objectRef = objectRef;
 
+    JPy_DIAG_PRINT(JPy_DIAG_F_MEM, "JObj_FromType: (Py_TYPE(&type->typeObj)->tp_basicsize=%d), (type->javaName=%s)\n", Py_TYPE(&type->typeObj)->tp_basicsize, type->javaName);
+
     // For special treatment of primitive array refer to JType_InitSlots()
     if (type->componentType != NULL && type->componentType->isPrimitive) {
         JPy_JArray* array;
 
         array = (JPy_JArray*) obj;
         array->bufferExportCount = 0;
         array->buf = NULL;
+    } else if (JByteBuffer_Check(type)) {
+        JPy_JByteBufferWrapper *byteBufferWrapper;
+        JPy_DIAG_PRINT(JPy_DIAG_F_MEM, "JObj_FromType: (Py_TYPE(&type->typeObj)->tp_basicsize=%d), (type->javaName=%s) setting byteBufferWrapper->pyBuffer=NULL\n", Py_TYPE(&type->typeObj)->tp_basicsize, type->javaName);
+        byteBufferWrapper = (JPy_JByteBufferWrapper *) obj;
+        byteBufferWrapper->pyBuffer = NULL;
     }
 
-    // we check the type translations dictionary for a callable for this java type name,
+
+// we check the type translations dictionary for a callable for this java type name,
     // and apply the returned callable to the wrapped object
     callable = PyDict_GetItemString(JPy_Type_Translations, type->javaName);
     if (callable != NULL) {
@@ -181,8 +190,16 @@ void JObj_dealloc(JPy_JObj* self)
         if (array->buf != NULL) {
             JArray_ReleaseJavaArrayElements(array, array->javaType);
         }
-
-    }    
+    } else if (JByteBuffer_Check(jtype)) {
+        JPy_JByteBufferWrapper *byteBufferWrapper;
+        JPy_DIAG_PRINT(JPy_DIAG_F_MEM, "JObj_dealloc: (jtype->javaName=%s) assuming JPy_JByteBufferWrapper, self->objectRef=%p\n", jtype->javaName, self->objectRef);
+        byteBufferWrapper = (JPy_JByteBufferWrapper *) self;
+        if (byteBufferWrapper->pyBuffer != NULL) {
+            JPy_DIAG_PRINT(JPy_DIAG_F_MEM, "JObj_dealloc: (jtype->javaName=%s) releasing JPy_JByteBufferWrapper, self->objectRef=%p, byteBufferWrapper->pyBuffer=%p\n", jtype->javaName, self->objectRef, byteBufferWrapper->pyBuffer);
+            PyBuffer_Release(byteBufferWrapper->pyBuffer);
+            PyMem_Free(byteBufferWrapper->pyBuffer);
+        }
+    }
 
     jenv = JPy_GetJNIEnv();
     if (jenv != NULL) {
@@ -727,7 +744,14 @@ int JType_InitSlots(JPy_JType* type)
     //Py_SET_TYPE(type, &JType_Type);
     //Py_SET_SIZE(type, sizeof (JPy_JType));
 
-    typeObj->tp_basicsize = isPrimitiveArray ? sizeof (JPy_JArray) : sizeof (JPy_JObj);
+    if (isPrimitiveArray) {
+        typeObj->tp_basicsize = sizeof(JPy_JArray);
+    } else if (JByteBuffer_Check(type)) {
+        typeObj->tp_basicsize = sizeof(JPy_JByteBufferWrapper);
+        JPy_DIAG_PRINT(JPy_DIAG_F_TYPE, "JType_InitSlots: allocating space for JPy_JByteBufferWrapper\n");
+    } else {
+        typeObj->tp_basicsize = sizeof(JPy_JObj);
+    }
     typeObj->tp_itemsize = 0;
     typeObj->tp_base = type->superType != NULL ? JTYPE_AS_PYTYPE(type->superType) : &JType_Type;
     //typeObj->tp_base = (PyTypeObject*) type->superType;
@@ -802,8 +826,8 @@ int JType_InitSlots(JPy_JType* type)
 
     //printf("+++++++++++++++++++++++++++++++++++++++++ typeObj->ob_type=%p\n", ((PyObject*)typeObj)->ob_type);
 
-    JPy_DIAG_PRINT(JPy_DIAG_F_TYPE, "JType_InitSlots: typeObj=%p, Py_TYPE(typeObj)=%p, typeObj->tp_name=\"%s\", typeObj->tp_base=%p, typeObj->tp_init=%p, &JType_Type=%p, &PyType_Type=%p, JObj_init=%p\n",
-                   typeObj, Py_TYPE(typeObj), typeObj->tp_name, typeObj->tp_base, typeObj->tp_init, &JType_Type, &PyType_Type, JObj_init);
+    JPy_DIAG_PRINT(JPy_DIAG_F_TYPE, "JType_InitSlots: typeObj=%p, Py_TYPE(typeObj)=%p, typeObj->tp_name=\"%s\", typeObj->tp_base=%p, typeObj->tp_init=%p, typeObj->tp_basicsize=%d, &JType_Type=%p, &PyType_Type=%p, JObj_init=%p\n",
+                   typeObj, Py_TYPE(typeObj), typeObj->tp_name, typeObj->tp_base, typeObj->tp_init, typeObj->tp_basicsize, &JType_Type, &PyType_Type, JObj_init);
 
     return 0;
 }
@@ -822,3 +846,13 @@ int JType_Check(PyObject* arg)
     return PyType_Check(arg) && JPY_IS_JTYPE(arg);
 }
 
+int JByteBuffer_Check(JPy_JType* type) {
+    while (type != NULL) {
+        if (type == JPy_JByteBuffer || strcmp(type->javaName, "java.nio.ByteBuffer") == 0) {
+            JPy_DIAG_PRINT(JPy_DIAG_F_TYPE, "JByteBuffer_Check: java ByteBuffer or its sub-type (%s) found.\n", type->javaName);
+            return -1;
+        }
+        type = type->superType;
+    }
+    return 0;
+}

src/main/c/jpy_jobj.h

@@ -40,6 +40,8 @@ JPy_JObj;
 
 int JObj_Check(PyObject* arg);
 
+int JByteBuffer_Check(JPy_JType* type);
+
 PyObject* JObj_New(JNIEnv* jenv, jobject objectRef);
 PyObject* JObj_FromType(JNIEnv* jenv, JPy_JType* type, jobject objectRef);
 

src/main/c/jpy_jtype.c

@@ -23,6 +23,7 @@
 #include "jpy_jfield.h"
 #include "jpy_jmethod.h"
 #include "jpy_jobj.h"
+#include "jpy_jbyte_buffer.h"
 #include "jpy_conv.h"
 #include "jpy_compat.h"
 
@@ -1659,7 +1660,6 @@ int JType_ConvertPyArgToJPyObjectArg(JNIEnv* jenv, JPy_ParamDescriptor* paramDes
     return JType_CreateJavaPyObject(jenv, JPy_JPyObject, pyArg, &value->l);
 }
 
-
 int JType_MatchPyArgAsJPyObjectParam(JNIEnv* jenv, JPy_ParamDescriptor* paramDescriptor, PyObject* pyArg)
 {
     // We can always turn a python object into a PyObject