Wrapper library

Wrapper libraries (or library wrappers) consist of a thin layer of code (a "shim") 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 (e.g. incompatible data formats)
Enable cross language and/or runtime interoperability

Wrapper libraries can be implemented using the adapter, façade, and to a lesser extent, proxy design patterns.

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. In this example, a C++ interface acts as a "wrapper" around a C interface.

C interface

int pthread_mutex_init(pthread_mutex_t * mutex , pthread_mutexattr_t * attr);
int pthread_mutex_destroy (pthread_mutex_t * mutex);
int pthread_mutex_lock (pthread_mutex_t * mutex );
int pthread_mutex_unlock (pthread_mutex_t * mutex );

C++ wrapper

class Mutex
{
     pthread_mutex_t mutex;

public:
     Mutex() 
     {
          pthread_mutex_init(&mutex, 0);
     }

     ~Mutex()
     {
          pthread_mutex_destroy(&mutex);
     }

private:
     friend class Lock;

     void lock()
     {
          pthread_mutex_lock(&mutex);
     }

     void unlock()
     {
          pthread_mutex_unlock(&mutex);
     }
};

class Lock
{
private:
      Mutex &mutex;

public:
      Lock(Mutex &mutex): mutex{mutex}
      {
            mutex.lock();
      }

      ~Lock()
      {
            mutex.unlock();
      }
};

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 (RAII) in the new Mutex and Lock classes to ensure Mutexs are eventually unlocked and pthread_mutex_t objects are automatically released.

The above code closely mimics the implementation of boost::scoped_lock and boost::mutex which are part of the boost::thread library.

Driver wrappers

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:

Existing wrapper libraries

Some examples of existing wrapper libraries:

Agama	Bahasa	Biografi	Budaya	Ekonomi	Elektronika
Film	Filsafat	Geografi	Indonesia	Ilmu	Lingkungan
Masyarakat	Matematika	Militer	Mitologi	Musik	Olahraga
Pendidikan	Politik	Sastra	Sejarah	Seni	Teknologi

Wrapper library

Structure and implementation

Example

C interface

C++ wrapper

Driver wrappers

Cross-language/runtime interoperability

Existing wrapper libraries

See also

Read other articles:

Murad Osmann

اتحاد إستونيا لكرة القدم

SMK Negeri 14 Bandung

2020 United States presidential election in Kentucky

1885

Elizabeth Street, Sydney

Bravia (brand)

Tas-Silġ

F1 22

大字 (数字)

Youth homelessness

Dassault Aviation

Freshwater, Conception Bay, Newfoundland and Labrador

Alba Party

روم أنطاكيون

Norman Kirk

Zaslon

Siltronic

Indiana

Thomas Schlamme

Portal di Ensiklopedia Dunia