Module.h

#pragma once
 
#include "../FoundationBase.h"
 
#if defined( _WIN32 )
  #include <WinSock2.h>
  #undef GetObject
#endif
 
#include <string>
 
namespace Cogs {
  class COGSFOUNDATION_API Module {
  public:
    enum class LoadStatus {
      Unloaded,
      Loaded,
      Failed,
    };
 
    LoadStatus  status = LoadStatus::Unloaded;
    void* handle = nullptr;
 
    virtual ~Module() = default;
    virtual void initPtrs()                            {}
 
    static void load( const std::string & path, LoadStatus & status, void*& handle );
    static void unload(void* handle);
 
    template<typename T = Module>
    static  T load( const std::string & path ) {
      T   instance;
 
      load( path, instance.status, instance.handle );
 
      if( instance.status == LoadStatus::Loaded ) {
        instance.initPtrs();
      }
      return instance;
    }
 
    template<typename T>
    void getProcAddress( T & ptr, const char* procName ) {
      ptr = reinterpret_cast< T >( getProcAddress( procName ) );
    }
 
    void* getProcAddress( const char* procName );
    static  void* getProcAddress( void* handle, const char* procName );
 
    bool operator ==( const Module & rhs ) const  { return ( status == rhs.status ) && ( handle == rhs.handle ); }
 
  protected:
    template<typename RET, typename FN, typename... ARGS>
    RET Call(FN* fn, ARGS... args) const {
      if (fn) {
        return (*fn)(args...);
      }
      return RET();
    }
  };
 
  template<typename API> class ModuleAPI : public Module {
  public:
    ModuleAPI() = default;
 
    ModuleAPI(void* h, const void* apiPtr) {
      status = LoadStatus::Loaded;
      handle = h;
      api = static_cast<const API*>(apiPtr);
    }
 
    ModuleAPI(const std::string& moduleName) {
      *this = load<ModuleAPI>(moduleName);
    }
 
    API* operator ->() {
      return const_cast<API*>(api);   // Cast away const because C++ reasons.  :(
    }
 
    virtual void initPtrs() override {
      const void* (*fn)() = reinterpret_cast<const void* (*)()>(getProcAddress(handle, "getPublicAPI"));
 
      if (fn) {
        api = static_cast<const API*>(fn());
      }
    }
 
  private:
    const API* api = nullptr;
  };
}