Work on interface

Author: Thrameos

native/jpype_module/src/main/java/org/jpype/JPypeContext.java

@@ -64,8 +64,6 @@
  * contents of JPJni.
  *
  *
- *
- * @author nelson85
  */
 public class JPypeContext
 {

native/jpype_module/src/main/java/org/jpype/JPypeKeywords.java

@@ -20,43 +20,103 @@
 import java.util.Set;
 
 /**
+ * Utility class for handling reserved keywords in JPype.
  *
- * @author nelson85
+ * This class provides methods to manage a set of reserved keywords and offers
+ * functionality to wrap and unwrap names to avoid conflicts with these
+ * keywords. It also includes a method to safely process package names
+ * containing underscores.
  */
 public class JPypeKeywords
 {
 
+  /**
+   * A set of reserved keywords.
+   *
+   * This set contains keywords that need special handling to avoid conflicts.
+   * Keywords can be added dynamically using the {@link #setKeywords(String[])}
+   * method.
+   */
   final public static Set<String> keywords = new HashSet<>();
 
+  /**
+   * Adds keywords to the reserved keywords set.
+   *
+   * This method allows dynamic addition of keywords to the {@link #keywords}
+   * set.
+   *
+   * @param s An array of strings representing the keywords to add.
+   */
   public static void setKeywords(String[] s)
   {
     keywords.addAll(Arrays.asList(s));
   }
 
+  /**
+   * Wraps a name if it matches a reserved keyword.
+   *
+   * If the given name is a reserved keyword, this method appends an underscore
+   * (`_`) to the name to avoid conflicts. Otherwise, it returns the name
+   * unchanged.
+   *
+   * @param name The name to check and wrap if necessary.
+   * @return The wrapped name if it is a keyword, otherwise the original name.
+   */
   public static String wrap(String name)
   {
     if (keywords.contains(name))
+    {
       return name + "_";
+    }
     return name;
   }
 
+  /**
+   * Unwraps a name that ends with an underscore (`_`).
+   *
+   * If the given name ends with an underscore and matches a reserved keyword
+   * (after removing the underscore), this method returns the original keyword.
+   * Otherwise, it returns the name unchanged.
+   *
+   * @param name The name to check and unwrap if necessary.
+   * @return The unwrapped name if it ends with an underscore and matches a
+   * keyword, otherwise the original name.
+   */
   public static String unwrap(String name)
   {
     if (!name.endsWith("_"))
+    {
       return name;
+    }
     String name2 = name.substring(0, name.length() - 1);
     if (keywords.contains(name2))
-      return name2;;
+    {
+      return name2;
+    }
     return name;
   }
 
+  /**
+   * Safely processes a package name by unwrapping parts containing underscores.
+   *
+   * This method splits the package name into its components (separated by
+   * dots), unwraps each part, and then reassembles the package name. It ensures
+   * that underscores are handled properly for each part of the package name.
+   *
+   * @param s The package name to process.
+   * @return The processed package name with unwrapped parts.
+   */
   static String safepkg(String s)
   {
     if (!s.contains("_"))
+    {
       return s;
+    }
     String[] parts = s.split("\\.");
     for (int i = 0; i < parts.length; ++i)
+    {
       parts[i] = unwrap(parts[i]);
+    }
     return String.join(".", parts);
   }
 }

native/jpype_module/src/main/java/org/jpype/JPypeReflector.java

@@ -3,17 +3,23 @@
 import java.lang.reflect.Method;
 
 /**
+ * Interface for invoking methods using reflection in JPype.
  *
- * @author nelson85
+ * The {@code JPypeReflector} interface provides a mechanism to call methods
+ * dynamically using Java reflection. This is particularly useful for invoking
+ * caller-sensitive methods while ensuring proper stack frame creation for
+ * execution.
  */
 public interface JPypeReflector
 {
 
   /**
-   * Call a method using reflection.
+   * Invokes a method using reflection.
    *
-   * This method creates a stackframe so that caller sensitive methods will
-   * execute properly.
+   * This method dynamically calls the specified method on the provided object
+   * (or class, if the method is static) using reflection. It ensures that
+   * caller-sensitive methods execute correctly by creating the appropriate
+   * stack frame during invocation.
    *
    * @param method is the method to call.
    * @param obj is the object to operate on, it will be null if the method is
@@ -23,6 +29,5 @@ public interface JPypeReflector
    * @throws java.lang.Throwable throws whatever type the called method
    * produces.
    */
-  public Object callMethod(Method method, Object obj, Object[] args)
-          throws Throwable;
+  public Object callMethod(Method method, Object obj, Object[] args) throws Throwable;
 }

native/jpype_module/src/main/java/org/jpype/PyExceptionProxy.java

@@ -2,7 +2,6 @@
 
 /**
  *
- * @author nelson85
  */
 public class PyExceptionProxy extends RuntimeException
 {