Wrapper-biblioteket - Wrapper library

Inslagningsbibliotek (eller biblioteksomslag) består av ett tunt lagerskikt (ett " shim ") som översätter ett biblioteks befintliga gränssnitt till ett kompatibelt gränssnitt. Detta görs av flera skäl:

  • Förfina ett dåligt utformat eller komplicerat gränssnitt
  • Låt koden fungera tillsammans som annars inte kan (t.ex. inkompatibla dataformat)
  • Aktivera interoperabilitet mellan olika språk och / eller runtime

Omslagsbibliotek kan implementeras med adapter , fasad och i mindre utsträckning proxy- designmönster .

Struktur och implementering

Det specifika sättet på vilket ett omslagsbibliotek implementeras är mycket specifikt för den miljö det skrivs i och de scenarier som det avser att ta itu med. Detta gäller särskilt när interoperabilitet mellan olika språk / runtime är en övervägande.

Exempel

Följande ger en allmän illustration av en gemensam omslagsbiblioteksimplementering. I detta exempel fungerar ett C ++ -gränssnitt som ett "omslag" runt ett C-språkgränssnitt.

C-gränssnitt

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 ++ omslag 

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

Det ursprungliga C-gränssnittet kan betraktas som felaktigt, särskilt i fall där användare av biblioteket glömmer att låsa upp en redan låst mutex. Det nya gränssnittet använder effektivt RAII (Resource Acquisition is Initialization) i de nya Mutex- och Lock- klasserna för att säkerställa att Mutex s så småningom låses upp och pthread_mutex_t- objekt släpps automatiskt.

Ovanstående kod efterliknar implementeringen av boost :: scoped_lock och boost :: mutex som är en del av boost :: thread- biblioteket.

Föraromslag

Ytterligare information: Förpackningsomslag

Interoperabilitet mellan olika språk / runtime

Vissa omslagsbibliotek finns för att fungera som en bro mellan en klientapplikation och ett bibliotek skrivet med en inkompatibel teknik. Till exempel kan en Java- applikation behöva köra ett systemsamtal . Emellertid exponeras systemsamtal som C-biblioteksfunktioner. För att lösa problemet implementerar Java omslagsbibliotek som gör att dessa systemsamtal kan kallas ut från en Java-applikation.

För att uppnå detta ger språk som Java en mekanism som kallas främmande funktionsgränssnitt som gör det möjligt. Några exempel på dessa mekanismer inkluderar:

Befintliga omslagsbibliotek

Några exempel på befintliga omslagsbibliotek:

Se även