Mercurial > octave

changeset 30045:849bd0f1129c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: use "m_" prefix for member variables of octave_value classes for Java. * ov-java.h, ov-java.cc: Rename member variables of class octave_java.
author Rik <rik@octave.org>
date Wed, 25 Aug 2021 14:40:16 -0700
parents 1f34286a2637
children b3717fd85e49
files libinterp/octave-value/ov-java.cc libinterp/octave-value/ov-java.h
diffstat 2 files changed, 42 insertions(+), 42 deletions(-) [+]
line wrap: on
line diff
--- a/libinterp/octave-value/ov-java.cc	Wed Aug 25 12:30:01 2021 -0700
+++ b/libinterp/octave-value/ov-java.cc	Wed Aug 25 14:40:16 2021 -0700
@@ -910,10 +910,10 @@
 
   JNIEnv *current_env = thread_jni_env ();
 
-  if (current_env && java_object)
+  if (current_env && m_java_object)
     {
       jclass_ref cls (current_env, current_env->FindClass ("java/lang/String"));
-      return current_env->IsInstanceOf (TO_JOBJECT (java_object), cls);
+      return current_env->IsInstanceOf (TO_JOBJECT (m_java_object), cls);
     }
 
   return false;
@@ -938,13 +938,13 @@
   std::string cls_cpp = cls_name;
   std::replace (cls_cpp.begin (), cls_cpp.end (), '.', '/');
 
-  if (current_env && java_object)
+  if (current_env && m_java_object)
     {
       jclass_ref cls (current_env, current_env->FindClass (cls_cpp.c_str ()));
       if (current_env->ExceptionCheck ())
         current_env->ExceptionClear ();
       else
-        return current_env->IsInstanceOf (TO_JOBJECT (java_object), cls);
+        return current_env->IsInstanceOf (TO_JOBJECT (m_java_object), cls);
     }
   return false;
 
@@ -1264,23 +1264,23 @@
 }
 
 static octave_value
-convert_to_string (JNIEnv *jni_env, jobject java_object, bool force, char type)
+convert_to_string (JNIEnv *jni_env, jobject m_java_object, bool force, char type)
 {
   octave_value retval;
 
-  if (jni_env && java_object)
+  if (jni_env && m_java_object)
     {
       jclass_ref cls (jni_env, jni_env->FindClass ("java/lang/String"));
 
-      if (jni_env->IsInstanceOf (java_object, cls))
-        retval = octave_value (jstring_to_string (jni_env, java_object), type);
+      if (jni_env->IsInstanceOf (m_java_object, cls))
+        retval = octave_value (jstring_to_string (jni_env, m_java_object), type);
       else if (force)
         {
           cls = jni_env->FindClass ("[Ljava/lang/String;");
 
-          if (jni_env->IsInstanceOf (java_object, cls))
+          if (jni_env->IsInstanceOf (m_java_object, cls))
             {
-              jobjectArray array = reinterpret_cast<jobjectArray> (java_object);
+              jobjectArray array = reinterpret_cast<jobjectArray> (m_java_object);
               int len = jni_env->GetArrayLength (array);
               Cell c (len, 1);
 
@@ -1305,7 +1305,7 @@
                                                     "()Ljava/lang/String;");
               jstring_ref js (jni_env,
                               reinterpret_cast<jstring>
-                                (jni_env->CallObjectMethod (java_object,
+                                (jni_env->CallObjectMethod (m_java_object,
                                                             mID)));
 
               if (js)
@@ -2113,7 +2113,7 @@
 //! Ctor.
 
 octave_java::octave_java (void)
-  : octave_base_value (), java_object (nullptr), java_class (nullptr)
+  : octave_base_value (), m_java_object (nullptr), m_java_class (nullptr)
 {
 #if ! defined (HAVE_JAVA)
 
@@ -2123,7 +2123,7 @@
 }
 
 octave_java::octave_java (const voidptr& jobj, void *jcls)
-  : octave_base_value (), java_object (nullptr), java_class (nullptr)
+  : octave_base_value (), m_java_object (nullptr), m_java_class (nullptr)
 {
 #if defined (HAVE_JAVA)
 
@@ -2165,8 +2165,8 @@
 
   JNIEnv *current_env = thread_jni_env ();
 
-  if (current_env && java_object)
-    return compute_array_dimensions (current_env, TO_JOBJECT (java_object));
+  if (current_env && m_java_object)
+    return compute_array_dimensions (current_env, TO_JOBJECT (m_java_object));
   else
     return dim_vector (1, 1);
 
@@ -2392,7 +2392,7 @@
 void
 octave_java::print_raw (std::ostream& os, bool) const
 {
-  os << "<Java object: " << java_classname << '>';
+  os << "<Java object: " << m_java_classname << '>';
 }
 
 // FIXME: Need routines to actually save/load java objects through Serialize.
@@ -2960,27 +2960,27 @@
   if (current_env)
     {
       if (jobj)
-        java_object = current_env->NewGlobalRef (jobj);
+        m_java_object = current_env->NewGlobalRef (jobj);
 
       if (jcls)
-        java_class = current_env->NewGlobalRef (jcls);
-      else if (java_object)
+        m_java_class = current_env->NewGlobalRef (jcls);
+      else if (m_java_object)
         {
           jclass_ref ocls (current_env,
-                           current_env->GetObjectClass(TO_JOBJECT (java_object)));
-          java_class = current_env->NewGlobalRef (jclass (ocls));
+                           current_env->GetObjectClass(TO_JOBJECT (m_java_object)));
+          m_java_class = current_env->NewGlobalRef (jclass (ocls));
         }
 
-      if (java_class)
+      if (m_java_class)
         {
           jclass_ref clsCls (current_env,
-                             current_env->GetObjectClass (TO_JCLASS (java_class)));
+                             current_env->GetObjectClass (TO_JCLASS (m_java_class)));
           jmethodID mID = current_env->GetMethodID (clsCls,
                                                     "getCanonicalName",
                                                     "()Ljava/lang/String;");
           jobject_ref resObj (current_env,
-                              current_env->CallObjectMethod (TO_JCLASS (java_class), mID));
-          java_classname = jstring_to_string (current_env, resObj);
+                              current_env->CallObjectMethod (TO_JCLASS (m_java_class), mID));
+          m_java_classname = jstring_to_string (current_env, resObj);
         }
     }
 
@@ -3006,14 +3006,14 @@
 
   if (current_env)
     {
-      if (java_object)
-        current_env->DeleteGlobalRef (TO_JOBJECT (java_object));
-
-      if (java_class)
-        current_env->DeleteGlobalRef (TO_JCLASS (java_class));
-
-      java_object = nullptr;
-      java_class = nullptr;
+      if (m_java_object)
+        current_env->DeleteGlobalRef (TO_JOBJECT (m_java_object));
+
+      if (m_java_class)
+        current_env->DeleteGlobalRef (TO_JCLASS (m_java_class));
+
+      m_java_object = nullptr;
+      m_java_class = nullptr;
     }
 
 #else
--- a/libinterp/octave-value/ov-java.h	Wed Aug 25 12:30:01 2021 -0700
+++ b/libinterp/octave-value/ov-java.h	Wed Aug 25 14:40:16 2021 -0700
@@ -48,17 +48,17 @@
   octave_java (const voidptr& obj, void *cls = nullptr);
 
   octave_java (const octave_java& jobj)
-    : octave_base_value (jobj), java_object (nullptr), java_class (nullptr)
+    : octave_base_value (jobj), m_java_object (nullptr), m_java_class (nullptr)
   {
-    init (jobj.java_object, jobj.java_class);
+    init (jobj.m_java_object, jobj.m_java_class);
   }
 
   ~octave_java (void) { release (); }
 
-  void * to_java (void) const { return java_object; }
-  void * to_class (void) const { return java_class; }
+  void * to_java (void) const { return m_java_object; }
+  void * to_class (void) const { return m_java_class; }
 
-  std::string java_class_name (void) const { return java_classname; }
+  std::string java_class_name (void) const { return m_java_classname; }
 
   octave_base_value * clone (void) const { return new octave_java (*this); }
   octave_base_value * empty_clone (void) const { return new octave_java (); }
@@ -172,17 +172,17 @@
 
 private:
 
-  void *java_object;
+  void *m_java_object;
 
-  void *java_class;
+  void *m_java_class;
 
-  std::string java_classname;
+  std::string m_java_classname;
 
 public:
 
   int type_id (void) const { return t_id; }
   std::string type_name (void) const { return t_name; }
-  std::string class_name (void) const { return java_classname; }
+  std::string class_name (void) const { return m_java_classname; }
 
   static int static_type_id (void) { return t_id; }
   static std::string static_type_name (void) { return t_name; }