Wrapper library: Difference between revisions
clean up, Replaced: → [[Run time (computing)|, using [[Project:AutoWikiBrowser|AWB |
mNo edit summary |
||
Line 3: | Line 3: | ||
'''Wrapper libraries''' (or library wrappers) consist of a thin layer of code which translates a library's existing interface into a compatible interface. This is done for several reasons: |
'''Wrapper libraries''' (or library wrappers) 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. |
* To refine a poorly designed or complicated interface. |
||
*Allow code to work together which otherwise cannot (e.g. Incompatible data formats). |
* Allow code to work together which otherwise cannot (e.g. Incompatible data formats). |
||
*Enable cross language and/or [[Run time (computing)|runtime]] interoperability. |
* Enable cross language and/or [[Run time (computing)|runtime]] interoperability. |
||
Wrapper libraries are implemented using the [[Adapter pattern|Adapter]], [[Facade pattern|Facade]], and to a lesser extent, [[Proxy pattern|Proxy]] [[Design pattern (computer science)|design patterns]]. |
Wrapper libraries are implemented using the [[Adapter pattern|Adapter]], [[Facade pattern|Facade]], and to a lesser extent, [[Proxy pattern|Proxy]] [[Design pattern (computer science)|design patterns]]. |
||
Line 12: | Line 12: | ||
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.2FRuntime_Interoperability|cross language/runtime interoperability]] is a consideration. |
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.2FRuntime_Interoperability|cross language/runtime interoperability]] is a consideration. |
||
===Example Implementation=== |
=== Example Implementation === |
||
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-language interface. |
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-language interface. |
||
Line 70: | Line 70: | ||
The above code closely mimics the implementation of <tt>boost::scoped_lock</tt> and <tt>boost::mutex</tt> which are part of the [http://www.boost.org/doc/libs/1_38_0/doc/html/thread.html boost::thread] library. |
The above code closely mimics the implementation of <tt>boost::scoped_lock</tt> and <tt>boost::mutex</tt> which are part of the [http://www.boost.org/doc/libs/1_38_0/doc/html/thread.html boost::thread] library. |
||
===Driver Wrappers=== |
=== Driver Wrappers === |
||
{{See |
{{See|Driver wrapper}} |
||
==Cross Language/Runtime Interoperability== |
== 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 (programming language)|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. |
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 (programming language)|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. |
||
Line 79: | Line 79: | ||
In order to achieve this, languages like Java provide mechanisms that make this possible. Some examples of these mechanisms include: |
In order to achieve this, languages like Java provide mechanisms that make this possible. Some examples of these mechanisms include: |
||
===Java Native Interface=== |
=== Java Native Interface === |
||
[[Java Native Interface|Java Native Interface (JNI)]] |
[[Java Native Interface|Java Native Interface (JNI)]] |
||
===ctypes Library (Python)=== |
=== ctypes Library (Python) === |
||
[http://docs.python.org/library/ctypes.html A foreign function library for Python] |
[http://docs.python.org/library/ctypes.html A foreign function library for Python] |
||
===Managed Extensions (C#)=== |
=== Managed Extensions (C#) === |
||
[[Managed Extensions for C++|Managed Extensions]] |
[[Managed Extensions for C++|Managed Extensions]] |
||
==Existing Wrapper Libraries== |
== Existing Wrapper Libraries == |
||
Some examples of existing wrapper libraries: |
Some examples of existing wrapper libraries: |
||
*[http://www.winehq.org/ Wine] |
* [http://www.winehq.org/ Wine] |
||
*[http://sourceware.org/pthreads-win32/ Pthreads for WIN32] |
* [http://sourceware.org/pthreads-win32/ Pthreads for WIN32] |
||
*[http://pyopengl.sourceforge.net/ OpenGL Bindings for Python] |
* [http://pyopengl.sourceforge.net/ OpenGL Bindings for Python] |
||
*[http://www.tangentsoft.net/mysql++/ MySQL++] |
* [http://www.tangentsoft.net/mysql++/ MySQL++] |
||
{{DEFAULTSORT:Wrapper Library}} |
{{DEFAULTSORT:Wrapper Library}} |
Revision as of 09:42, 16 January 2010
In computer programming, a library is a collection of subroutines or classes used to develop software. Libraries expose interfaces which clients of the library use to execute library routines.
Wrapper libraries (or library wrappers) 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 (e.g. Incompatible data formats).
- Enable cross language and/or runtime interoperability.
Wrapper libraries are implemented using the Adapter, Facade, and to a lesser extent, Proxy design patterns.
Structure / Implementaiton
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 Implementation
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-language 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() : mutex(0)
{
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
{
Mutex& mutex;
public:
Lock(Mutex& mutex):mutex(mutex){mutex.lock();}
~Lock(Mutex& mutex):mutex(mutex){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 RAII (Resource Acquisition is Initialization) 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 mechanisms that make this possible. Some examples of these mechanisms include:
Java Native Interface
ctypes Library (Python)
A foreign function library for Python
Managed Extensions (C#)
Existing Wrapper Libraries
Some examples of existing wrapper libraries: