java-native-access/jna

Features

• Native Function Invocations - JNA allows the invocation of functions within shared native libraries across different operating systems without writing custom JNI wrapper code.
• Native Library Integrations - Enables calling functions in shared native libraries from Java without writing custom JNI wrapper code.
• Native Data Marshallers - Converts complex Java objects and structures into contiguous byte buffers matching C-style memory layouts.
• JNI Alternatives - Provides a high-level interface for invoking C functions and mapping native data structures as an alternative to JNI.
• Direct Memory Access - Provides the ability to read and write raw memory addresses to handle native pointers and global variables.
• Dynamic Library Loading - Locates and loads native libraries from system paths, environment variables, or bundled classpath resources.
• Native Memory Mappers - Translates Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange.
• Platform API Access - Utilizes pre-defined mappings for common system functions to simplify cross-platform native access.
• Platform Library Mappings - Provides built-in mappings of common native functions to simplify access to platform-specific system calls.
• System Call Interfacing - Provides a unified interface for executing low-level operating system calls across different platforms.
• Function-Pointer Callbacks - Enables mapping Java methods to native function pointers, allowing external libraries to trigger logic within the JVM.
• Foreign Function Interfaces - Binds Java method signatures to native symbols in shared libraries across different operating systems.
• Native Callbacks - Maps high-level methods to C-style function pointers so native libraries can trigger logic within the runtime.
• Data Structure Mappings - Represents C-style structs, nested structures, and arrays to exchange complex data with native libraries.
• Native Memory Lifecycle Management - Handles pointers, by-reference arguments, and buffers to exchange raw memory blocks between runtime and native layers.
• Native Access Libraries - Serves as a comprehensive library for calling native shared libraries from Java without custom JNI glue code.
• Method Interception Proxies - Uses dynamic proxy systems to intercept method calls and translate arguments into native memory representations.
• Native Bridges - Provides a low-level bridge using the Java Native Interface to execute native code without custom wrappers.
• Native Callbacks - Allows Java methods to be passed as function pointers so native libraries can trigger logic within the runtime.
• COM Component Integration - Supports early and late binding for COM objects and generates code from Typelibs.
• Component Object Model Handlers - Provides interfaces for invoking registered Windows Component Object Model handlers.
• COM Integration - Provides a dedicated toolkit for interacting with Windows Component Object Model objects using early and late binding.
• Native Crash Protection - Intercepts memory access errors during native calls to throw exceptions instead of crashing the virtual machine.
• Raw Memory Allocation - Allocates contiguous blocks of memory for arrays of structures to be consumed by native functions.
• Runtime Symbol Resolution - Locates and binds native function addresses within shared libraries using platform-specific loading mechanisms.
• Direct Native Method Mapping - Binds native library functions to static or instance methods to achieve higher execution performance than standard mapping.
• Dynamic Native Invocation - Enables invoking functions from shared libraries using direct lookups without defining static interfaces.
• Native String Marshaling - Converts strings to NUL-terminated char or wchar_t arrays and copies returned native strings back into the runtime.
• Calling Conventions - Translates interface method signatures into native function names based on platform-specific calling conventions.
• Global Variable Mappings - Obtains memory addresses of global variables in a native library to read or write their values.
• Union Mappings - Supports defining classes that represent C-style unions and specifying the active field.
• Native Function Pointer Invocations - JNA supports calling functions referenced by pointers found within native structures by automatically generating proxy wrappers.
• Native Method Registration - Reduces execution overhead by creating optimized code stubs for native methods to avoid runtime reflection.
• Native Method Resolution Strategies - Provides custom mappers to resolve naming mismatches when looking up native function symbols.
• Native Symbol Mapping - Connects method signatures to native symbols using direct name matching or custom mapping for coding conventions.
• Reference Argument Passing - Supports passing pointers to types to native functions to capture values updated by the external library.
• Type Mapping Registries - Maintains a mapping between high-level data types and native representations based on platform calling conventions.
• Native Error Retrieval - Captures native error codes from system calls and exposes them as exceptions or numeric values.
• Mobile Development - Interface for calling native libraries without JNI.

Star history