JCOBridge

java.lang.Object
- org.mases.jcobridge.JCHandler
- - org.mases.jcobridge.JCOBridge

```
public final class JCOBridge
extends JCHandler
```
Main entry point for JVM→CLR interop via JCOBridge.
This class manages the full lifecycle of the CLR runtime hosted inside the JVM process: initialization, assembly loading, type resolution, object instantiation, and global object registration. It also provides factory methods for AWT UI integration and diagnostic logging.

Typical usage from a JVM-hosted application:
1. Optionally configure paths and options via the static setters or command-line switches.
2. Call Initialize(String[]) (or Initialize()) to load the native bridge and start the CLR runtime.
3. Call CreateNew() to obtain a JCOBridge instance.
4. Use the instance methods (AddReference(java.lang.String), GetType(java.lang.String), NewObject(java.lang.String, java.lang.Object...), etc.) to interact with CLR assemblies and types.
Configuration can be provided in three ways, evaluated in this order of precedence:
1. Programmatic setters (setNativePath(java.lang.String), setLicensePath(java.lang.String), etc.).
2. Command-line arguments passed to Initialize(String[]).
3. Environment variables (e.g. JCOBRIDGE_NativePath, JCOBRIDGE_LicensePath).
See also: JCOReflector for usage examples.
Since:

1.0.0.0

Author:

MASES S.R.L.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`AddPath(String path)` Adds a directory to the CLR assembly search path.
`JCAssembly`	`AddReference(String assemblyName)` Loads a CLR assembly by name and returns a handle to it.
`static IJCGraphicContainer`	`CreateContainer(Component comp)` Creates an `IJCGraphicContainer` wrapping the given AWT component, enabling it to be embedded in a CLR UI host (e.g.
`static IJCGraphicContainer`	`CreateContainer(String className)` Creates an `IJCGraphicContainer` from a class name.
`static JCOBridge`	`CreateNew()` Creates and returns a new `JCOBridge` instance backed by a fresh CLR context.
`static Object`	`GetCLRGlobal(String key)` Retrieves a previously registered CLR global object by key.
`static String`	`getCLRRID()` Returns the .NET Runtime Identifier (RID) override used to select the correct CoreCLR host activator library.
`JCControl`	`GetControl(String type)` Returns a `JCControl` handle to a graphical CLR object, suitable for embedding CLR controls (WinForms, WPF) into an AWT/Swing host.
`static Boolean`	`getCoreCLREnableDesktop()` Returns `true` if `Microsoft.WindowsDesktop.App` hosting is enabled.
`static String`	`getCoreCLRVersion()` Returns the target .NET major version used to select the hosting framework.
`JCEnum`	`GetEnum(String type)` Resolves a CLR enum type by its fully qualified name and returns a handle to it.
`static String[]`	`getFilteredArgs()` Returns the command-line arguments that were not consumed by JCOBridge during `Initialize(String[])`.
`static boolean`	`getGlobalize()` Returns whether the hosted .NET Core instance will be globalized.
`JCJControl`	`GetJControl(String type)` Returns a `JCJControl` handle to a graphical CLR object, suitable for embedding CLR controls into a Swing host via a dedicated Swing-aware wrapper.
`static Object`	`GetJVMGlobal(String key)` Retrieves a previously registered JVM global object by key.
`static String`	`getLicensePath()` Returns the path where the JCOBridge license file is located.
`static String`	`getNativePath()` Returns the path from which the JCOBridge native library is loaded.
`static String`	`getScopedOn()` Returns the scoped-on value used for license validation.
`static String`	`getScopedOnVersion()` Returns the scoped-on version used for license validation.
`JCType`	`GetType(String type)` Resolves a CLR type by its fully qualified name and returns a handle to it.
`static void`	`Initialize()` Initializes the JCOBridge runtime with default parameters.
`static void`	`Initialize(String[] args)` Initializes the JCOBridge runtime, consuming JCOBridge-specific arguments from `args` and storing the remainder in `filteredArgs`.
`static void`	`InitializeFromRemote(String J2CBridgeCanonicalPath, String licencePath, String scopedOn, String scopedOnVersion, boolean globalize)` Initializes the JCOBridge native bridge from a CLR-hosted process.
`static Boolean`	`isCLRHostingProcess()` Returns `true` if the hosting process is a CLR (i.e.
`static Boolean`	`isNET10HostingProcess()` Returns whether the hosting CLR is .NET 10.
`static Boolean`	`isNET6HostingProcess()` Returns whether the hosting CLR is .NET 6.
`static Boolean`	`isNET8HostingProcess()` Returns whether the hosting CLR is .NET 8.
`static Boolean`	`isNET9HostingProcess()` Returns whether the hosting CLR is .NET 9.
`static Boolean`	`isNETFrameworkHostingProcess()` Returns whether the hosting CLR is .NET Framework.
`static Boolean`	`isNETHostingProcess(Integer netVersion)` Returns whether the hosting CLR is the specified major .NET version.
`static void`	`Load()` Loads the CLR/JVM wrapper library for Windows (`J2CBridge_x64.dll` or `J2CBridge_x86.dll`), resolved relative to the JCOBridge JAR location.
`static void`	`LoadWrapper(String libraryName)` Loads the CLR/JVM wrapper library from the given absolute path.
`Object`	`NewObject(JCType type, Object... params)` Creates a new instance of the CLR type represented by the given `JCType` handle, passing optional constructor arguments.
`Object`	`NewObject(String type, Object... params)` Creates a new instance of the specified CLR type, passing optional constructor arguments.
`void`	`RegisterEventLog(IJCEventLog logger)` Registers a diagnostic logger with the CLR context.
`static void`	`RegisterJVMGlobal(String key, Object obj)` Registers a JVM object in the global shared map, making it accessible from the CLR side by key.
`static void`	`setCLRRID(String rid)` Sets the .NET Runtime Identifier (RID) override.
`static void`	`setCoreCLREnableDesktop(Boolean value)` Enables or disables `Microsoft.WindowsDesktop.App` hosting.
`static void`	`setCoreCLRVersion(String clrApp)` Sets the target .NET major version.
`static void`	`setGlobalize(boolean globalize)` Controls whether the hosted .NET Core instance will be globalized.
`static void`	`setLicensePath(String path)` Sets the path where the JCOBridge license file is located.
`static void`	`setNativePath(String path)` Sets the path from which the JCOBridge native library is loaded.
`static void`	`setScopedOn(String value)` Sets the scoped-on value for license validation.
`static void`	`setScopedOnVersion(String value)` Sets the scoped-on version for license validation.
`static void`	`SetWrapperPath(String path)` Sets the path to the CLR/JVM wrapper library.
`static void`	`UnregisterJVMGlobal(String key)` Unregisters a JVM object from the global shared map, removing it from both the native registry and `registeredObjectsMap`, allowing it to be collected by the GC.

Methods inherited from class org.mases.jcobridge.JCHandler
getReference

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getFilteredArgs
```
public static String[] getFilteredArgs()
```
    Returns the command-line arguments that were not consumed by JCOBridge during Initialize(String[]). These are the arguments that should be forwarded to the application.
    
    Returns:
    
    the filtered argument array, or null if Initialize(String[]) has not been called yet.
  - getNativePath
```
public static String getNativePath()
```
    Returns the path from which the JCOBridge native library is loaded. Defaults to the directory containing JCOBridge.jar, overridable via setNativePath(java.lang.String) or the JCOBRIDGE_NativePath environment variable.
    
    Returns:
    
    the effective native library path, or an empty string if not set.
  - setNativePath
```
public static void setNativePath(String path)
```
    Sets the path from which the JCOBridge native library is loaded. Must be an existing directory; throws IllegalArgumentException otherwise. Must be called before Initialize().
    
    Parameters:
    
    path - the directory path containing the native bridge libraries.
    
    Throws:
    
    IllegalArgumentException - if path does not refer to an existing directory.
  - getLicensePath
```
public static String getLicensePath()
```
    Returns the path where the JCOBridge license file is located. Defaults to the local folder, overridable via setLicensePath(java.lang.String) or the JCOBRIDGE_LicensePath environment variable. HTTP/HTTPS URLs are also accepted.
    
    Returns:
    
    the effective license path, or an empty string if not set.
  - setLicensePath
```
public static void setLicensePath(String path)
```
    Sets the path where the JCOBridge license file is located. Must be an existing directory; throws IllegalArgumentException otherwise. Must be called before Initialize().
    
    Parameters:
    
    path - the directory path containing the license file.
    
    Throws:
    
    IllegalArgumentException - if path does not refer to an existing directory.
  - getCLRRID
```
public static String getCLRRID()
```
    Returns the .NET Runtime Identifier (RID) override used to select the correct CoreCLR host activator library. An empty string means the RID is auto-detected from OS and architecture properties.
    
    Returns:
    
    the effective RID string, or an empty string if auto-detection is active.
  - setCLRRID
```
public static void setCLRRID(String rid)
```
    Sets the .NET Runtime Identifier (RID) override. Set this when auto-detection fails or produces an incorrect result for the target platform. Must be called before Initialize().
    
    Parameters:
    
    rid - the RID string (e.g. "linux-x64", "win-x64").
  - getCoreCLRVersion
```
public static String getCoreCLRVersion()
```
    Returns the target .NET major version used to select the hosting framework. Valid values are "8" (default), "9", and "10".
    
    Returns:
    
    the effective .NET major version string.
  - setCoreCLRVersion
```
public static void setCoreCLRVersion(String clrApp)
```
    Sets the target .NET major version. Valid values are "8", "9", and "10". Throws IllegalArgumentException for any other value. Must be called before Initialize().
    
    Parameters:
    
    clrApp - the .NET major version string.
    
    Throws:
    
    IllegalArgumentException - if clrApp is not a recognized version.
  - getCoreCLREnableDesktop
```
public static Boolean getCoreCLREnableDesktop()
```
    Returns true if Microsoft.WindowsDesktop.App hosting is enabled. This option is only valid on Windows — attempting to initialize with it on Linux or macOS will throw a JCException.
    
    Returns:
    
    true if desktop hosting is requested.
  - setCoreCLREnableDesktop
```
public static void setCoreCLREnableDesktop(Boolean value)
```
    Enables or disables Microsoft.WindowsDesktop.App hosting. Must be called before Initialize(). Only valid on Windows.
    
    Parameters:
    
    value - true to enable desktop features.
  - getScopedOn
```
public static String getScopedOn()
```
    Returns the scoped-on value used for license validation. An empty string means no scoping is applied.
    
    Returns:
    
    the effective scoped-on value.
  - setScopedOn
```
public static void setScopedOn(String value)
```
    Sets the scoped-on value for license validation. Must be called before Initialize().
    
    Parameters:
    
    value - the scoped-on value.
  - getScopedOnVersion
```
public static String getScopedOnVersion()
```
    Returns the scoped-on version used for license validation. An empty string means no version scoping is applied.
    
    Returns:
    
    the effective scoped-on version.
  - setScopedOnVersion
```
public static void setScopedOnVersion(String value)
```
    Sets the scoped-on version for license validation. Must be called before Initialize().
    
    Parameters:
    
    value - the scoped-on version.
  - getGlobalize
```
public static boolean getGlobalize()
```
    Returns whether the hosted .NET Core instance will be globalized. Globalization affects culture-sensitive operations within the CLR. Defaults to true.
    
    Returns:
    
    true if the CLR instance will be globalized.
  - setGlobalize
```
public static void setGlobalize(boolean globalize)
```
    Controls whether the hosted .NET Core instance will be globalized. Set to false to run in invariant globalization mode, which reduces resource usage and startup time but disables culture-sensitive operations. Must be called before Initialize().
    
    Parameters:
    
    globalize - false to disable globalization.
  - isCLRHostingProcess
```
public static Boolean isCLRHostingProcess()
```
    Returns true if the hosting process is a CLR (i.e. JCOBridge was started from .NET rather than from a JVM main). Detected via the jcobridge.started.from.clr system property set by the native bridge at startup.
    
    Returns:
    
    true if the current process was started by a CLR host.
  - isNETFrameworkHostingProcess
```
public static Boolean isNETFrameworkHostingProcess()
```
    Returns whether the hosting CLR is .NET Framework.
    
    Returns:
    
    null if the host is a JVM; true if the host is .NET Framework; false if the host is .NET (Core).
  - isNETHostingProcess
```
public static Boolean isNETHostingProcess(Integer netVersion)
```
    Returns whether the hosting CLR is the specified major .NET version. The check is performed by testing whether the jcobridge.started.from.clr system property starts with the given version number string.
    
    Parameters:
    
    netVersion - the major .NET version to check (e.g. 8, 10).
    
    Returns:
    
    null if the host is a JVM; true if the host is the specified .NET version; false otherwise.
  - isNET6HostingProcess
```
public static Boolean isNET6HostingProcess()
```
    Returns whether the hosting CLR is .NET 6.
    
    Returns:
    
    null if the host is a JVM; true if .NET 6; false otherwise.
  - isNET8HostingProcess
```
public static Boolean isNET8HostingProcess()
```
    Returns whether the hosting CLR is .NET 8.
    
    Returns:
    
    null if the host is a JVM; true if .NET 8; false otherwise.
  - isNET9HostingProcess
```
public static Boolean isNET9HostingProcess()
```
    Returns whether the hosting CLR is .NET 9.
    
    Returns:
    
    null if the host is a JVM; true if .NET 9; false otherwise.
  - isNET10HostingProcess
```
public static Boolean isNET10HostingProcess()
```
    Returns whether the hosting CLR is .NET 10.
    
    Returns:
    
    null if the host is a JVM; true if .NET 10; false otherwise.
  - SetWrapperPath
```
public static void SetWrapperPath(String path)
```
    Sets the path to the CLR/JVM wrapper library.
    Internal use only. Called by the JCOBridge infrastructure before CreateNew() to point the instance constructor at the correct wrapper.
    
    Parameters:
    
    path - the absolute or relative path to the wrapper library.
  - Load
```
public static void Load()
                 throws IOException
```
    Loads the CLR/JVM wrapper library for Windows (J2CBridge_x64.dll or J2CBridge_x86.dll), resolved relative to the JCOBridge JAR location.
    Internal use only. Called by the CLR host when JCOBridge is started from .NET Framework.
    
    Throws:
    
    IOException - if the library path cannot be resolved or the library cannot be loaded.
  - LoadWrapper
```
public static void LoadWrapper(String libraryName)
                        throws IOException
```
    Loads the CLR/JVM wrapper library from the given absolute path.
    Internal use only. Called by the CLR host when the library path is known at the point of invocation (e.g. when JCOBridge is started from .NET Core).
    
    Parameters:
    
    libraryName - the absolute path to the native wrapper library.
    
    Throws:
    
    IOException - if the library cannot be loaded.
  - Initialize
```
public static void Initialize()
                       throws JCNativeException,
                              JCException,
                              IOException
```
    Initializes the JCOBridge runtime with default parameters.
    Settings are read from the JCOBRIDGE_JVM_SETTINGS environment variable (if present) and from the static fields set via the programmatic setters. Each setting in the environment variable must be separated by &&:
```
 JCOBRIDGE_JVM_SETTINGS=--NativePath:/opt/jcobridge&&--LicensePath:/opt/license
 
```
    Throws:
    
    JCNativeException - if something happens within the CLR context.
    
    JCException - if initialization fails at the library level.
    
    IOException - if a required file or directory cannot be accessed.
    
    Since:
    
    2.0.0.0
  - Initialize
```
public static void Initialize(String[] args)
                       throws IOException,
                              JCException
```
    Initializes the JCOBridge runtime, consuming JCOBridge-specific arguments from args and storing the remainder in filteredArgs.
    Arguments from the JCOBRIDGE_JVM_SETTINGS environment variable (if present) are merged with args before processing. Each environment variable entry must be separated by &&.
    
    Parameters:
    
    args - the full argument array from main(String[] args).
    
    Throws:
    
    IOException - if a required file or directory cannot be accessed.
    
    JCException - if initialization fails at the library level.
    
    Since:
    
    2.1.0.0
  - InitializeFromRemote
```
public static void InitializeFromRemote(String J2CBridgeCanonicalPath,
                                        String licencePath,
                                        String scopedOn,
                                        String scopedOnVersion,
                                        boolean globalize)
                                 throws JCNativeException,
                                        IOException
```
    Initializes the JCOBridge native bridge from a CLR-hosted process.
    Do not call directly. Invoked by the CLR host when the JVM is started from .NET rather than the other way around.
    
    Parameters:
    
    J2CBridgeCanonicalPath - the canonical path to the loaded native bridge library.
    
    licencePath - the license file path or URL.
    
    scopedOn - the scoped-on value for license validation.
    
    scopedOnVersion - the scoped-on version for license validation.
    
    globalize - false to run in invariant globalization mode.
    
    Throws:
    
    JCNativeException - if the native initialization fails.
    
    IOException - if a required file cannot be accessed.
    
    Since:
    
    2.0.0.0
  - CreateNew
```
public static JCOBridge CreateNew()
                           throws JCNativeException
```
    Creates and returns a new JCOBridge instance backed by a fresh CLR context. Initialize() must have been called before invoking this method.
    
    Returns:
    
    a new JCOBridge instance.
    
    Throws:
    
    JCNativeException - if the CLR context cannot be created.
  - RegisterJVMGlobal
```
public static void RegisterJVMGlobal(String key,
                                     Object obj)
                              throws JCNativeException
```
    Registers a JVM object in the global shared map, making it accessible from the CLR side by key. The object is also stored in registeredObjectsMap to prevent premature GC collection while it is registered.
    
    Parameters:
    
    key - the key to identify the registered object.
    
    obj - the object to register.
    
    Throws:
    
    JCNativeException - if the native registration fails.
  - UnregisterJVMGlobal
```
public static void UnregisterJVMGlobal(String key)
                                throws JCNativeException
```
    Unregisters a JVM object from the global shared map, removing it from both the native registry and registeredObjectsMap, allowing it to be collected by the GC.
    
    Parameters:
    
    key - the key of the object to unregister.
    
    Throws:
    
    JCNativeException - if the native unregistration fails.
  - GetJVMGlobal
```
public static Object GetJVMGlobal(String key)
                           throws JCNativeException
```
    Retrieves a previously registered JVM global object by key.
    
    Parameters:
    
    key - the registration key.
    
    Returns:
    
    the registered object.
    
    Throws:
    
    JCNativeException - if the native lookup fails or the key is not found.
  - GetCLRGlobal
```
public static Object GetCLRGlobal(String key)
                           throws JCNativeException
```
    Retrieves a previously registered CLR global object by key. CLR global objects are registered from the .NET side and made accessible here.
    
    Parameters:
    
    key - the registration key.
    
    Returns:
    
    the CLR object wrapped for JVM access.
    
    Throws:
    
    JCNativeException - if the native lookup fails or the key is not found.
  - CreateContainer
```
public static IJCGraphicContainer CreateContainer(Component comp)
```
    Creates an IJCGraphicContainer wrapping the given AWT component, enabling it to be embedded in a CLR UI host (e.g. a WinForms or WPF panel).
    
    Parameters:
    
    comp - the AWT Component to embed.
    
    Returns:
    
    a new IJCGraphicContainer wrapping comp.
  - CreateContainer
```
public static IJCGraphicContainer CreateContainer(String className)
                                           throws InstantiationException,
                                                  IllegalAccessException,
                                                  ClassNotFoundException,
                                                  JCException
```
    Creates an IJCGraphicContainer from a class name. The class must either implement IJCGraphicContainer directly or extend Component (in which case it is wrapped automatically).
    
    Parameters:
    
    className - the fully qualified class name to instantiate.
    
    Returns:
    
    a new IJCGraphicContainer instance.
    
    Throws:
    
    IllegalAccessException - if the class or its nullary constructor is not accessible.
    
    InstantiationException - if the class is abstract, an interface, an array, a primitive, or void; or has no nullary constructor.
    
    ClassNotFoundException - if the class cannot be located.
    
    JCException - if the instantiated class is neither an IJCGraphicContainer nor a Component.
  - RegisterEventLog
```
public void RegisterEventLog(IJCEventLog logger)
                      throws JCNativeException
```
    Registers a diagnostic logger with the CLR context. Log events generated by the bridge will be forwarded to logger via the IJCEventLog interface.
    
    Parameters:
    
    logger - the IJCEventLog instance to register.
    
    Throws:
    
    JCNativeException - if the registration fails within the CLR context.
  - AddPath
```
public void AddPath(String path)
             throws JCNativeException
```
    Adds a directory to the CLR assembly search path. Assemblies in this directory will be discoverable by subsequent AddReference(java.lang.String) calls.
    
    Parameters:
    
    path - the directory path to add to the CLR assembly search path.
    
    Throws:
    
    JCNativeException - if the operation fails within the CLR context.
  - AddReference
```
public JCAssembly AddReference(String assemblyName)
                        throws JCNativeException
```
    Loads a CLR assembly by name and returns a handle to it. The assembly name follows standard .NET conventions (simple name, fully qualified name, or file path).
    
    Parameters:
    
    assemblyName - the name or path of the CLR assembly to load.
    
    Returns:
    
    a JCAssembly handle to the loaded assembly.
    
    Throws:
    
    JCNativeException - if the assembly cannot be found or loaded.
  - GetType
```
public JCType GetType(String type)
               throws JCNativeException
```
    Resolves a CLR type by its fully qualified name and returns a handle to it.
    
    Parameters:
    
    type - the fully qualified CLR type name (e.g. "System.Collections.ArrayList").
    
    Returns:
    
    a JCType handle to the resolved type.
    
    Throws:
    
    JCNativeException - if the type cannot be found.
  - GetEnum
```
public JCEnum GetEnum(String type)
               throws JCNativeException
```
    Resolves a CLR enum type by its fully qualified name and returns a handle to it.
    
    Parameters:
    
    type - the fully qualified CLR enum type name.
    
    Returns:
    
    a JCEnum handle to the resolved enum type.
    
    Throws:
    
    JCNativeException - if the enum type cannot be found.
  - GetControl
```
public JCControl GetControl(String type)
                     throws JCNativeException
```
    Returns a JCControl handle to a graphical CLR object, suitable for embedding CLR controls (WinForms, WPF) into an AWT/Swing host.
    
    Parameters:
    
    type - the fully qualified CLR type name of the graphical object.
    
    Returns:
    
    a JCControl handle.
    
    Throws:
    
    JCNativeException - if the type cannot be found or instantiated.
  - GetJControl
```
public JCJControl GetJControl(String type)
                       throws JCNativeException
```
    Returns a JCJControl handle to a graphical CLR object, suitable for embedding CLR controls into a Swing host via a dedicated Swing-aware wrapper.
    
    Parameters:
    
    type - the fully qualified CLR type name of the graphical object.
    
    Returns:
    
    a JCJControl handle.
    
    Throws:
    
    JCNativeException - if the type cannot be found or instantiated.
  - NewObject
```
public Object NewObject(String type,
                        Object... params)
                 throws JCNativeException
```
    Creates a new instance of the specified CLR type, passing optional constructor arguments. Primitive CLR types (bool, float, String, etc.) are returned as their Java equivalents; all other types are returned as JCObject.
    
    Parameters:
    
    type - the fully qualified CLR type name to instantiate.
    
    params - optional constructor arguments.
    
    Returns:
    
    the new CLR object, as a Java primitive or JCObject.
    
    Throws:
    
    JCNativeException - if the type cannot be found or the constructor fails.
  - NewObject
```
public Object NewObject(JCType type,
                        Object... params)
                 throws JCNativeException
```
    Creates a new instance of the CLR type represented by the given JCType handle, passing optional constructor arguments.
    
    Parameters:
    
    type - the JCType handle of the CLR type to instantiate.
    
    params - optional constructor arguments.
    
    Returns:
    
    the new CLR object, as a Java primitive or JCObject.
    
    Throws:
    
    JCNativeException - if the constructor fails.

Class JCOBridge

Method Summary

Methods inherited from class org.mases.jcobridge.JCHandler

Methods inherited from class java.lang.Object

Method Detail

getFilteredArgs

getNativePath

setNativePath

getLicensePath

setLicensePath

getCLRRID

setCLRRID

getCoreCLRVersion

setCoreCLRVersion

getCoreCLREnableDesktop

setCoreCLREnableDesktop

getScopedOn

setScopedOn

getScopedOnVersion

setScopedOnVersion

getGlobalize

setGlobalize

isCLRHostingProcess

isNETFrameworkHostingProcess

isNETHostingProcess

isNET6HostingProcess

isNET8HostingProcess

isNET9HostingProcess

isNET10HostingProcess

SetWrapperPath

Load

LoadWrapper

Initialize

Initialize

InitializeFromRemote

CreateNew

RegisterJVMGlobal

UnregisterJVMGlobal

GetJVMGlobal

GetCLRGlobal

CreateContainer

CreateContainer

RegisterEventLog

AddPath

AddReference

GetType

GetEnum

GetControl

GetJControl

NewObject

NewObject