dlloader.h

Go to the documentation of this file.

#ifndef DLLOADER_H
#define DLLOADER_H

#include <memory>
#include <stdexcept>
#include <string>

#if defined(WIN32) && !defined(__CYGWIN__)
#include "windows.h"
#else
#include <dlfcn.h>
#endif

// fix MacOS missing RTLD_DEEPBIND flag in dlopen
#if defined(__APPLE__)
#undef RTLD_DEEPBIND
#define RTLD_DEEPBIND 0
#endif

namespace dlloader {
  template <typename T>
  class DLLoaderInterface {
  public:
    virtual ~DLLoaderInterface() = default;
    virtual void DLOpenLib() = 0;
    virtual std::shared_ptr<T> DLGetInstance() = 0;
    virtual void DLCloseLib() = 0;
    virtual std::string LibName() const = 0;
  };
#if defined (WIN32)
  template <typename T>
  class DLLoader: public DLLoaderInterface<T> {
  private:
    HMODULE mHandle;
    std::string mPathToLib;
    std::string mAllocClassSymbol;
    std::string mDeleteClassSymbol;
  public:
    DLLoader(
      std::string pathToLib,
      std::string allocClassSymbol = "allocator",
      std::string deleteClassSymbol = "deleter"):
      mPathToLib(std::move(pathToLib)),
      mAllocClassSymbol(std::move(allocClassSymbol)),
      mDeleteClassSymbol(std::move(deleteClassSymbol)) {}
    ~DLLoader() = default;
    void DLOpenLib() override {
      if (!(mHandle = LoadLibrary(mPathToLib.c_str()))) {
        throw std::runtime_error(std::string{"Cannot open and load "} + mPathToLib);
      }
    }
    void DLCloseLib() override {
      if (FreeLibrary(mHandle) == 0) {
        throw std::runtime_error(std::string{"Cannot close "} + mPathToLib);
      }
    }
    std::shared_ptr<T> DLGetInstance() override {
      using allocClass = T *(*)();
      using deleteClass = void (*)(T *);
      auto allocFunc = reinterpret_cast<allocClass>(GetProcAddress(mHandle, mAllocClassSymbol.c_str()));
      auto deleteFunc = reinterpret_cast<deleteClass>(GetProcAddress(mHandle, mDeleteClassSymbol.c_str()));
      if (!allocFunc || !deleteFunc) {
        try {
          DLCloseLib();
        } catch (...) {
          throw;
        }
        throw std::runtime_error(std::string{"Cannot find allocator or deleter symbol in "} + mPathToLib);
      }
      return std::shared_ptr<T>(allocFunc(), [deleteFunc](T* p){deleteFunc(p);});
    }
    std::string LibName() const override {
      return mPathToLib;
    }
  };
#else
  template <typename T>
  class DLLoader: public DLLoaderInterface<T> {
  private:
    void* mHandle;
    std::string mPathToLib;
    std::string mAllocClassSymbol;
    std::string mDeleteClassSymbol;
  public:
    DLLoader(
      std::string pathToLib,
      std::string allocClassSymbol = "allocator",
      std::string deleteClassSymbol = "deleter"):
      mPathToLib(std::move(pathToLib)),
      mAllocClassSymbol(std::move(allocClassSymbol)),
      mDeleteClassSymbol(std::move(deleteClassSymbol)) {}
    ~DLLoader() = default;
    void DLOpenLib() override {
      if (!(mHandle = dlopen(mPathToLib.c_str(), RTLD_NOW|RTLD_LAZY|RTLD_DEEPBIND))) {
        throw std::runtime_error(std::string{dlerror()});
      }
    }
    void DLCloseLib() override {
      if (dlclose(mHandle) != 0) {
        throw std::runtime_error(std::string{dlerror()});
      }
    }
    std::shared_ptr<T> DLGetInstance() override {
      using allocClass = T *(*)();
      using deleteClass = void (*)(T *);
      auto allocFunc = reinterpret_cast<allocClass>(dlsym(mHandle, mAllocClassSymbol.c_str()));
      auto deleteFunc = reinterpret_cast<deleteClass>(dlsym(mHandle, mDeleteClassSymbol.c_str()));
      if (!allocFunc || !deleteFunc) {
        try {
          DLCloseLib();
          throw std::runtime_error(std::string{dlerror()});
        } catch (...) {
          throw;
        }
        throw std::runtime_error(std::string{dlerror()});
      }
      return std::shared_ptr<T>(allocFunc(), [deleteFunc](T* p){deleteFunc(p);});
    }
    std::string LibName() const override {
      return mPathToLib;
    }
  };
#endif
}

#endif // DLLOADER_H