Szerkesztő:Kadosknight/próbalap

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:

Kapcsolódó szócikkek[szerkesztés]

[[Kategória:Számítógép-programozás]]