Las bibliotecas contenedoras (o envoltorios de bibliotecas ) constan de una fina capa de código (una " shim ") que traduce la interfaz existente de una biblioteca en una interfaz compatible. Esto se hace por varias razones:
Las bibliotecas contenedoras se pueden implementar utilizando los patrones de diseño adaptador , fachada y, en menor medida, proxy .
La forma específica en la que se implementa una biblioteca contenedora es muy específica del entorno en el que se escribe y de los escenarios que pretende abordar. Esto es especialmente cierto en el caso en que se considera la interoperabilidad entre lenguajes y tiempo de ejecución.
A continuación se proporciona una ilustración general de una implementación de biblioteca contenedora común. En este ejemplo, una interfaz C++ actúa como un "envoltorio" alrededor de una interfaz C.
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 ); clase Mutex { pthread_mutex_t mutex ; público : Mutex () { pthread_mutex_init ( & mutex , 0 ); } ~ Mutex () { pthread_mutex_destroy ( & mutex ); } privado : bloqueo de clase de amigo ; bloqueo vacío () { pthread_mutex_lock ( & mutex ); } desbloqueo vacío () { pthread_mutex_unlock ( & mutex ); } }; bloqueo de clase { privado : Mutex y mutex ; público : Bloquear ( Mutex y mutex ) : mutex { mutex } { mutex . cerrar (); } ~ Bloquear () { mutex . desbloquear (); } }; La interfaz C original puede considerarse propensa a errores, particularmente en el caso en que los usuarios de la biblioteca olvidan desbloquear un mutex ya bloqueado. La nueva interfaz utiliza eficazmente la adquisición de recursos e inicialización (RAII) en las nuevas clases Mutex y Lock para garantizar que los Mutex finalmente se desbloqueen y que los objetos pthread_mutex_t se liberen automáticamente.
El código anterior imita fielmente la implementación de boost::scoped_lock y boost::mutex , que forman parte de la biblioteca boost::thread.
Algunas bibliotecas contenedoras existen para actuar como puente entre una aplicación cliente y una biblioteca escrita utilizando una tecnología incompatible. Por ejemplo, es posible que una aplicación Java necesite ejecutar una llamada al sistema . Sin embargo, las llamadas al sistema suelen exponerse como funciones de la biblioteca C. Para resolver este problema, Java implementa bibliotecas contenedoras que hacen que estas llamadas al sistema sean invocables desde una aplicación Java.
Para lograr esto, lenguajes como Java proporcionan un mecanismo llamado interfaz de función externa que lo hace posible. Algunos ejemplos de estos mecanismos incluyen:
Algunos ejemplos de bibliotecas contenedoras existentes: