src/stdlib/vxlibrary.hpp

   1
   2 #include "helper.hpp"
   3 #include "sharedlib.h"
   4
   5
   6 class VXSharedLibrary {
   7     public:
   8         class Error: public std::runtime_error {
   9             public:
  10                 Error():
  11                     std::runtime_error("VXSharedLibrary::Error")
  12                 {}
  13
  14                 Error(const std::string& msg):
  15                     std::runtime_error(msg)
  16                 {}
  17
  18                 virtual ~Error() throw()
  19                 {}
  20         };
  21
  22         class LoadError: public VXSharedLibrary::Error {
  23             public:
  24                 LoadError(const std::string& msg):
  25                     VXSharedLibrary::Error(msg.c_str())
  26                 {
  27                 }
  28         };
  29
  30         class SymbolError: public VXSharedLibrary::Error {
  31             public:
  32                 SymbolError(const std::string& msg):
  33                     VXSharedLibrary::Error(msg.c_str())
  34                 {
  35                 }
  36         };
  37
  38         class CloseError: public VXSharedLibrary::Error {
  39             public:
  40                 CloseError(const std::string& msg):
  41                     VXSharedLibrary::Error(msg.c_str())
  42                 {
  43                 }
  44         };
  45
  46         class NotOpenError: public VXSharedLibrary::Error {
  47             public:
  48                 NotOpenError(const std::string& msg):
  49                     VXSharedLibrary::Error(msg.c_str())
  50                 {
  51                 }
  52         };
  53
  54     public:
  55         static VXSharedLibrary openSelf()
  56         {
  57             VXSharedLibrary lib(shl_openself());
  58             return lib;
  59         }
  60
  61
  62     private:
  63         shl_handle_t* m_handle;
  64         std::string errormessage;
  65         std::string message;
  66         bool m_isclosed;
  67
  68     private:
  69         std::string lasterr()
  70         {
  71             const char* err = shl_geterrstr(m_handle);
  72             if(err == NULL)
  73             {
  74                 return strerror(errno);
  75             }
  76             return err;
  77         }
  78
  79         void setup()
  80         {
  81             m_isclosed = false;
  82         }
  83
  84     public:
  85         VXSharedLibrary()
  86         {
  87         }
  88
  89         VXSharedLibrary(shl_handle_t* ctx)
  90         {
  91             this->setup();
  92             this->m_handle = ctx;
  93         }
  94
  95         VXSharedLibrary(const std::string& path)
  96         {
  97             this->setup();
  98             this->open(path);
  99         }
 100
 101         ~VXSharedLibrary()
 102         {}
 103
 104         void open(const std::string& path)
 105         {
 106             this->setup();
 107             this->m_handle = shl_openlib(path.c_str());
 108             if(this->m_handle == NULL)
 109             {
 110                 this->destroy();
 111                 throw VXSharedLibrary::LoadError(this->lasterr());
 112             }
 113         }
 114
 115         void* resolve(const std::string& funcname)
 116         {
 117             void* ptr;
 118             ptr = shl_resolve(this->m_handle, funcname.c_str());
 119             if(ptr == NULL)
 120             {
 121                 throw VXSharedLibrary::SymbolError(this->lasterr());
 122             }
 123             return ptr;
 124         }
 125
 126         template<typename func_t> func_t resolve(const std::string& name)
 127         {
 128             return forcecast<func_t>(this->resolve(name));
 129         }
 130
 131         void destroy()
 132         {
 133             shl_destroy(this->m_handle);
 134         }
 135
 136         void close()
 137         {
 138             if(this->m_handle != NULL)
 139             {
 140                 if(!m_isclosed)
 141                 {
 142                     shl_closelib(this->m_handle);
 143                     m_isclosed = true;
 144                 }
 145                 else
 146                 {
 147                     shl_destroy(this->m_handle);
 148                 }
 149             }
 150             else
 151             {
 152                 shl_destroy(this->m_handle);
 153             }
 154         }
 155 };