Wrapper library
Wrapper libraries consist of a thin layer of code which translates a library's existing interface into a compatible interface. This is done for several reasons:
- To refine a poorly designed or complicated interface
- Allow code to work together which otherwise cannot
- Enable cross language and/or runtime interoperability
Structure and implementation
The specific way in which a wrapper library is implemented is highly specific to the environment it is being written in and the scenarios which it intends to address. This is especially true in the case when cross-language/runtime interoperability is a consideration.Example
The following provides a general illustration of a common wrapper library implementation over a C POSIX library header . In this example, a C++ interface acts as a "wrapper" around a C interface.C interface
In :- include
int pthread_mutex_init;
int pthread_mutex_destroy;
int pthread_mutex_lock;
int pthread_mutex_unlock;
// more functions...
C++ wrapper
Wrapping with :export module org.posix.PosixThread;
import
export namespace org::posix
The original C interface can be regarded as error prone, particularly in the case where users of the library forget to unlock an already locked mutex. The new interface effectively utilizes resource acquisition is initialization in the new and classes to ensure s are eventually unlocked and objects are automatically released.
The above code closely mimics the implementation of and classes from Boost which are part of the library.
Cross-language/runtime interoperability
Some wrapper libraries exist to act as a bridge between a client application and a library written using an incompatible technology. For instance, a Java application may need to execute a system call. However system calls are typically exposed as C library functions. To resolve this issue Java implements wrapper libraries which make these system calls callable from a Java application.In order to achieve this, languages like Java provide a mechanism called foreign function interface that makes this possible. Some examples of these mechanisms include:
- Java Native Interface and Java Foreign Function and Memory API
- Java Native Access
- Managed Extensions
- SWIG (Simplified Wrapper and Interface Generator)
std::ffilibrary