Modernize to c++14 for gcc/clang like compilers

jpype/_core.py

@@ -51,11 +51,14 @@ class JVMNotRunning(RuntimeError):
 
 # Activate jedi tab completion
 try:
-    import jedi as _jedi
-    _jedi.evaluate.compiled.access.ALLOWED_DESCRIPTOR_ACCESS += \
-        (_jpype._JMethod, _jpype._JField)
-except Exception:
+    from jedi import __version__ as _jedi_version
+    import jedi.access as _jedi_access
+    _jedi_access.ALLOWED_DESCRIPTOR_ACCESS += _jpype._JMethod, _jpype._JField
+except ModuleNotFoundError:
     pass
+except AttributeError:
+    import warnings as _w
+    _w.warn(f"provided Jedi seems out of date. Version is {_jedi_version}.")
 
 
 if typing.TYPE_CHECKING:

native/common/include/jp_array.h

@@ -23,21 +23,21 @@ class JPArray;
 class JPArrayView
 {
 public:
-	JPArrayView(JPArray* array);
+	explicit JPArrayView(JPArray* array);
 	JPArrayView(JPArray* array, jobject collection);
 	~JPArrayView();
 	void reference();
 	bool unreference();
-	JPContext *getContext();
+	JPContext *getContext() const;
 public:
 	JPArray *m_Array;
-	void *m_Memory;
-	Py_buffer m_Buffer;
+	void *m_Memory{};
+	Py_buffer m_Buffer{};
 	int m_RefCount;
-	Py_ssize_t m_Shape[5];
-	Py_ssize_t m_Strides[5];
-	jboolean m_IsCopy;
-	jboolean m_Owned;
+	Py_ssize_t m_Shape[5]{};
+	Py_ssize_t m_Strides[5]{};
+	jboolean m_IsCopy{};
+	jboolean m_Owned{};
 } ;
 
 /**
@@ -47,7 +47,7 @@ class JPArray
 {
 	friend class JPArrayView;
 public:
-	JPArray(const JPValue& array);
+	explicit JPArray(const JPValue& array);
 	JPArray(JPArray* cls, jsize start, jsize stop, jsize step);
 	virtual~ JPArray();
 
@@ -56,7 +56,7 @@ class JPArray
 		return m_Class;
 	}
 
-	jsize     getLength();
+	jsize     getLength() const;
 	void       setRange(jsize start, jsize length, jsize step, PyObject* val);
 	JPPyObject getItem(jsize ndx);
 	void       setItem(jsize ndx, PyObject*);

native/common/include/jp_arrayclass.h

@@ -28,11 +28,11 @@ class JPArrayClass : public JPClass
 			JPClass* superClass,
 			JPClass* componentType,
 			jint modifiers);
-	virtual~ JPArrayClass();
+	~ JPArrayClass() override;
 
-	virtual JPPyObject convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
-	virtual JPMatch::Type findJavaConversion(JPMatch &match) override;
-	virtual void getConversionInfo(JPConversionInfo &info) override;
+	JPPyObject convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
+	JPMatch::Type findJavaConversion(JPMatch &match) override;
+	void getConversionInfo(JPConversionInfo &info) override;
 
 	JPValue newArray(JPJavaFrame& frame, int length);
 
@@ -54,7 +54,7 @@ class JPArrayClass : public JPClass
 		return m_ComponentType;
 	}
 
-	virtual bool isArray() const override
+	bool isArray() const override
 	{
 		return true;
 	}

native/common/include/jp_booleantype.h

@@ -21,10 +21,10 @@ class JPBooleanType : public JPPrimitiveType
 public:
 
 	JPBooleanType();
-	virtual ~JPBooleanType();
+	~JPBooleanType() override;
 
-	typedef jboolean type_t;
-	typedef jbooleanArray array_t;
+	using type_t = jboolean;
+	using array_t = jbooleanArray;
 
 	static inline jboolean& field(jvalue& v)
 	{
@@ -36,32 +36,32 @@ class JPBooleanType : public JPPrimitiveType
 		return v.z;
 	}
 
-	virtual JPClass* getBoxedClass(JPContext *context) const override
+	JPClass* getBoxedClass(JPContext *context) const override
 	{
 		return context->_java_lang_Boolean;
 	}
 
-	virtual JPMatch::Type findJavaConversion(JPMatch& match) override;
-	virtual void getConversionInfo(JPConversionInfo &info) override;
-	virtual JPPyObject  convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
-	virtual JPValue     getValueFromObject(const JPValue& obj) override;
+	JPMatch::Type findJavaConversion(JPMatch& match) override;
+	void getConversionInfo(JPConversionInfo &info) override;
+	JPPyObject  convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
+	JPValue     getValueFromObject(const JPValue& obj) override;
 
-	virtual JPPyObject  invokeStatic(JPJavaFrame& frame, jclass, jmethodID, jvalue*) override;
-	virtual JPPyObject  invoke(JPJavaFrame& frame, jobject, jclass, jmethodID, jvalue*) override;
+	JPPyObject  invokeStatic(JPJavaFrame& frame, jclass, jmethodID, jvalue*) override;
+	JPPyObject  invoke(JPJavaFrame& frame, jobject, jclass, jmethodID, jvalue*) override;
 
-	virtual JPPyObject  getStaticField(JPJavaFrame& frame, jclass c, jfieldID fid) override;
-	virtual void        setStaticField(JPJavaFrame& frame, jclass c, jfieldID fid, PyObject* val) override;
-	virtual JPPyObject  getField(JPJavaFrame& frame, jobject c, jfieldID fid) override;
-	virtual void        setField(JPJavaFrame& frame, jobject c, jfieldID fid, PyObject* val) override;
+	JPPyObject  getStaticField(JPJavaFrame& frame, jclass c, jfieldID fid) override;
+	void        setStaticField(JPJavaFrame& frame, jclass c, jfieldID fid, PyObject* val) override;
+	JPPyObject  getField(JPJavaFrame& frame, jobject c, jfieldID fid) override;
+	void        setField(JPJavaFrame& frame, jobject c, jfieldID fid, PyObject* val) override;
 
-	virtual jarray      newArrayOf(JPJavaFrame& frame, jsize size) override;
-	virtual void        setArrayRange(JPJavaFrame& frame, jarray,
+	jarray      newArrayOf(JPJavaFrame& frame, jsize size) override;
+	void        setArrayRange(JPJavaFrame& frame, jarray,
 			jsize start, jsize length, jsize step,
 			PyObject *sequence) override;
-	virtual JPPyObject  getArrayItem(JPJavaFrame& frame, jarray, jsize ndx) override;
-	virtual void        setArrayItem(JPJavaFrame& frame, jarray, jsize ndx, PyObject* val) override;
+	JPPyObject  getArrayItem(JPJavaFrame& frame, jarray, jsize ndx) override;
+	void        setArrayItem(JPJavaFrame& frame, jarray, jsize ndx, PyObject* val) override;
 
-	virtual char getTypeCode() override
+	char getTypeCode() override
 	{
 		return 'Z';
 	}
@@ -70,26 +70,26 @@ class JPBooleanType : public JPPrimitiveType
 	// These methods are required by primitive but are not used for a non
 	// number type
 
-	virtual jlong getAsLong(jvalue v) override
+	jlong getAsLong(jvalue v) override
 	{
 		return field(v);
 	}
 
-	virtual jdouble getAsDouble(jvalue v) override
+	jdouble getAsDouble(jvalue v) override
 	{
 		return field(v);
 	}
 	// GCOVR_EXCL_STOP
 
-	virtual void getView(JPArrayView& view) override;
-	virtual void releaseView(JPArrayView& view) override;
-	virtual const char* getBufferFormat() override;
-	virtual Py_ssize_t getItemSize() override;
-	virtual void copyElements(JPJavaFrame &frame,
+	void getView(JPArrayView& view) override;
+	void releaseView(JPArrayView& view) override;
+	const char* getBufferFormat() override;
+	Py_ssize_t getItemSize() override;
+	void copyElements(JPJavaFrame &frame,
 			jarray a, jsize start, jsize len,
 			void* memory, int offset) override;
 
-	virtual PyObject *newMultiArray(JPJavaFrame &frame,
+	PyObject *newMultiArray(JPJavaFrame &frame,
 			JPPyBuffer &buffer, int subs, int base, jobject dims) override;
 
 } ;

native/common/include/jp_boxedtype.h

@@ -36,18 +36,18 @@ class JPBoxedType : public JPClass
 			JPClassList& interfaces,
 			jint modifiers,
 			JPPrimitiveType* primitiveType);
-	virtual ~JPBoxedType();
+	~JPBoxedType() override;
 
-	virtual JPMatch::Type findJavaConversion(JPMatch &match) override;
-	virtual void getConversionInfo(JPConversionInfo &info) override;
+	JPMatch::Type findJavaConversion(JPMatch &match) override;
+	void getConversionInfo(JPConversionInfo &info) override;
 
 	JPPrimitiveType* getPrimitive()
 	{
 		return m_PrimitiveType;
 	}
 
 	jobject box(JPJavaFrame &frame, jvalue v);
-	virtual JPPyObject convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
+	JPPyObject convertToPythonObject(JPJavaFrame& frame, jvalue val, bool cast) override;
 
 protected:
 	JPPrimitiveType* m_PrimitiveType;

native/common/include/jp_buffer.h

@@ -26,7 +26,7 @@ class JPBufferType;
 class JPBuffer
 {
 public:
-	JPBuffer(const JPValue& array);
+	explicit JPBuffer(const JPValue& array);
 	virtual~ JPBuffer();
 
 	JPBufferType* getClass()
@@ -39,19 +39,19 @@ class JPBuffer
 		return m_Object.get();
 	}
 
-	bool isReadOnly();
+	bool isReadOnly() const;
 
 	Py_buffer& getView();
 
-	bool isValid();
+	bool isValid() const;
 
 private:
 	JPBufferType* m_Class;
 	JPObjectRef m_Object;
 	void *m_Address;
 	Py_ssize_t m_Capacity;
-	Py_buffer m_Buffer;
-	char m_Format[3];
+	Py_buffer m_Buffer{};
+	char m_Format[3]{};
 } ;
 
 #endif // _JPBUFFER_H_

native/common/include/jp_buffertype.h

@@ -23,14 +23,14 @@ class JPBufferType : public JPClass
 {
 public:
 	JPBufferType(JPJavaFrame& frame, jclass cls, const string& name, JPClass* superClass, const JPClassList& interfaces, jint modifiers);
-	virtual~ JPBufferType();
+	~ JPBufferType() override;
 
-	char* getType()
+	const char* getType()
 	{
-		return const_cast<char*> (m_Type);
+		return m_Type;
 	}
 
-	int getSize()
+	int getSize() const
 	{
 		return m_Size;
 	}

native/common/include/jp_bytetype.h

@@ -21,11 +21,11 @@ class JPByteType : public JPPrimitiveType
 public:
 
 	JPByteType();
-	virtual ~JPByteType() override;
+	~JPByteType() override;
 
 public:
-	typedef jbyte type_t;
-	typedef jbyteArray array_t;
+	using type_t = jbyte;
+	using array_t = jbyteArray;
 
 	static inline jbyte& field(jvalue& v)
 	{
@@ -37,30 +37,30 @@ class JPByteType : public JPPrimitiveType
 		return v.b;
 	}
 
-	virtual JPClass* getBoxedClass(JPContext *context) const override
+	JPClass* getBoxedClass(JPContext *context) const override
 	{
 		return context->_java_lang_Byte;
 	}
 
-	virtual JPMatch::Type findJavaConversion(JPMatch &match) override;
-	virtual void getConversionInfo(JPConversionInfo &info) override;
-	virtual JPPyObject  convertToPythonObject(JPJavaFrame &frame, jvalue val, bool cast) override;
-	virtual JPValue     getValueFromObject(const JPValue& obj) override;
+	JPMatch::Type findJavaConversion(JPMatch &match) override;
+	void getConversionInfo(JPConversionInfo &info) override;
+	JPPyObject  convertToPythonObject(JPJavaFrame &frame, jvalue val, bool cast) override;
+	JPValue     getValueFromObject(const JPValue& obj) override;
 
-	virtual JPPyObject  invokeStatic(JPJavaFrame& frame, jclass, jmethodID, jvalue*) override;
-	virtual JPPyObject  invoke(JPJavaFrame& frame, jobject, jclass, jmethodID, jvalue*) override;
+	JPPyObject  invokeStatic(JPJavaFrame& frame, jclass, jmethodID, jvalue*) override;
+	JPPyObject  invoke(JPJavaFrame& frame, jobject, jclass, jmethodID, jvalue*) override;
 
-	virtual JPPyObject  getStaticField(JPJavaFrame& frame, jclass c, jfieldID fid) override;
-	virtual void        setStaticField(JPJavaFrame& frame, jclass c, jfieldID fid, PyObject* val) override;
-	virtual JPPyObject  getField(JPJavaFrame& frame, jobject c, jfieldID fid) override;
-	virtual void        setField(JPJavaFrame& frame, jobject c, jfieldID fid, PyObject* val) override;
+	JPPyObject  getStaticField(JPJavaFrame& frame, jclass c, jfieldID fid) override;
+	void        setStaticField(JPJavaFrame& frame, jclass c, jfieldID fid, PyObject* val) override;
+	JPPyObject  getField(JPJavaFrame& frame, jobject c, jfieldID fid) override;
+	void        setField(JPJavaFrame& frame, jobject c, jfieldID fid, PyObject* val) override;
 
-	virtual jarray      newArrayOf(JPJavaFrame& frame, jsize size) override;
-	virtual void        setArrayRange(JPJavaFrame& frame, jarray, jsize start, jsize length, jsize step, PyObject*) override;
-	virtual JPPyObject  getArrayItem(JPJavaFrame& frame, jarray, jsize ndx) override;
-	virtual void        setArrayItem(JPJavaFrame& frame, jarray, jsize ndx, PyObject* val) override;
+	jarray      newArrayOf(JPJavaFrame& frame, jsize size) override;
+	void        setArrayRange(JPJavaFrame& frame, jarray, jsize start, jsize length, jsize step, PyObject*) override;
+	JPPyObject  getArrayItem(JPJavaFrame& frame, jarray, jsize ndx) override;
+	void        setArrayItem(JPJavaFrame& frame, jarray, jsize ndx, PyObject* val) override;
 
-	virtual char getTypeCode() override
+	char getTypeCode() override
 	{
 		return 'B';
 	}
@@ -74,25 +74,25 @@ class JPByteType : public JPPrimitiveType
 		return l;
 	}
 
-	virtual jlong getAsLong(jvalue v) override
+	jlong getAsLong(jvalue v) override
 	{
 		return field(v);
 	}
 
-	virtual jdouble getAsDouble(jvalue v) override
+	jdouble getAsDouble(jvalue v) override
 	{
 		return field(v);
 	}
 
-	virtual void getView(JPArrayView& view) override;
-	virtual void releaseView(JPArrayView& view) override;
-	virtual const char* getBufferFormat() override;
-	virtual Py_ssize_t getItemSize() override;
-	virtual void copyElements(JPJavaFrame &frame,
+	void getView(JPArrayView& view) override;
+	void releaseView(JPArrayView& view) override;
+	const char* getBufferFormat() override;
+	Py_ssize_t getItemSize() override;
+	void copyElements(JPJavaFrame &frame,
 			jarray a, jsize start, jsize len,
 			void* memory, int offset) override;
 
-	virtual PyObject *newMultiArray(JPJavaFrame &frame,
+	PyObject *newMultiArray(JPJavaFrame &frame,
 			JPPyBuffer &buffer, int subs, int base, jobject dims) override;
 
 private: