Csomagoló könyvtár

A csomagoló könyvtárak (vagy könyvtár csomagolók) egy vékony kódréteget (avagy "shim"-et) képeznek, amely átfordítja egy könyvtár meglévő interfészét egy másik, kompatibilis interfésszé. Ezt több okból teszi:

Hogy finomítson egy rosszul tervezett vagy bonyolult interfészen
Lehetővé tegye olyan kódrészek együttműködését, amelyek másként nem tudnának (pl. az inkompatibilis adatformátumaik miatt)
Lehetővé tegyen nyelvek közötti és/vagy futásidejű interoperabilitást

Csomagoló könyvtárak implementálhatók az adapter, a façade, és kisebb mértékben a proxy tervezési mintázat által.

Szerkezet és implementáció szerkesztés

Egy csomagólo könyvtár implementációjának módja erősen függ attól a környezettől, amelyben írják, és azoktól az esetektől, amelyekre használni akarják. Ez különösen igaz abban az esetben, amikor a nyelvek közötti/futásidejű interoperabilitást is számba kell venni.

Példa szerkesztés

Az alábbi egy általános illusztrációval szolgál egy hétköznapi csomagoló könyvtár implementációjára. Ebben a példában egy C++ interfész játssza a "csomagoló" szerepét egy C nyelvű interfész körül.

C interfész szerkesztés

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++ csomagoló szerkesztés

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();
      }
};

Az eredeti C interfészt tekinthetjük hibára hajlamosnak, különösen abban az esetben, mikor a könyvtár használói elfelejtenek kinyitni egy már lezárt mutexet. Az új interfész hatásosan használja a RAII (Resource Acquisition is Initialization) elvet az új Mutex és Lock osztályokban, hogy biztosítsa, hogy a Mutexek előbb-utóbb kinyitásra kerülnek és a pthread_mutex_t objektumok automatikusan felszabadulnak.

A fenti kód megközelítően utánozza a boost::scoped_lock és a boost::mutex implementációját, amelyek a boost::thread könyvtár részei.

Driver csomagolók szerkesztés

További információk: Hardver-illesztőprogram

Nyelvek közötti/futásidejű interoperabilitás szerkesztés

Egyes csomagoló könyvtárak célja, hogy hídként szolgáljanak egy kliens alkalmazás és egy könyvtár között, amelyeket inkompatibilis technológiákkal írtak. Például egy Java applikációnak lehet, hogy végre kell hajtania egy rendszerhívást (system call). De a rendszerhívások általában C könyvtár funkciókként vannak szolgáltatva. Hogy megoldja ezt a problémát, a Java csomagoló könyvtárakat implementál, amelyek meghívhatóvá teszik ezeket a rendszerhívásokat egy Java applikációból.

Ennek eléréséhez a Java-hoz hasonló nyelvek egy idegen funkció interfésznek (en:foreign function interface) hívott mechanizmust nyújtanak, ami ezt lehetővé teszi. Néhány példa az ilyen mechanizmusokra:

Létező csomagoló könyvtárak szerkesztés

Néhány példa már létező csomagoló könyvtárakra:

Fordítás szerkesztés

Ez a szócikk részben vagy egészben a Wrapper library című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.