module.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <span>
#include <string_view>
#include <type_traits>
#include <vector>
 
#include <rex/platform.h>
#include <rex/result.h>
#include <rex/types.h>
#include <rex/utility.h>
#include <rex/version.h>
 
namespace rex {
 
namespace detail {
 
template <typename T>
constexpr const char* FunctionSignature() {
#if defined(__clang__) || defined(__GNUC__)
  return __PRETTY_FUNCTION__;
#else
  return __FUNCSIG__;
#endif
}
 
template <typename T>
constexpr std::string_view ExtractTypeName() {
  std::string_view signature = FunctionSignature<T>();
#if defined(__clang__) || defined(__GNUC__)
  constexpr std::string_view kMarker = "T = ";
  const size_t begin = signature.find(kMarker) + kMarker.size();
  const size_t end = signature.find_first_of(";]", begin);
#else
  constexpr std::string_view kMarker = "FunctionSignature<";
  const size_t begin = signature.find(kMarker) + kMarker.size();
  const size_t end = signature.rfind(">(");
#endif
  std::string_view name = signature.substr(begin, end - begin);
  for (std::string_view prefix :
       {std::string_view("class "), std::string_view("struct "), std::string_view("enum ")}) {
    if (name.starts_with(prefix)) {
      name.remove_prefix(prefix.size());
    }
  }
  return name;
}
 
template <typename T>
inline constexpr auto kTypeNameChars = [] {
  constexpr std::string_view kName = ExtractTypeName<T>();
  std::array<char, kName.size() + 1> chars{};
  for (size_t i = 0; i < kName.size(); ++i) {
    chars[i] = kName[i];
  }
  return chars;
}();

template <typename T>
inline constexpr const char* kTypeName = kTypeNameChars<T>.data();
 
}  // namespace detail

struct InterfaceType {
  const char* name; 
  u32 version;
  bool is_private = false; 
};

class IInterface : NonCopyable {
 public:
  virtual ~IInterface() = default;
};

#define REX_DETAIL_ID(x) x

#define REX_DECLARE_INTERFACE(Name, version)             \
  class REX_DETAIL_ID(Name) : public ::rex::IInterface { \
   public:                                               \
    static constexpr ::rex::InterfaceType kInterface{::rex::detail::kTypeName<Name>, version};

#define REX_DECLARE_PRIVATE_INTERFACE(Name, version)     \
  class REX_DETAIL_ID(Name) : public ::rex::IInterface { \
   public:                                               \
    static constexpr ::rex::InterfaceType kInterface{::rex::detail::kTypeName<Name>, version, true};

class IInterfaceFactory {
 public:
  virtual ~IInterfaceFactory() = default;

  virtual IInterface* Find(std::string_view name, u32 version) = 0;

  virtual std::vector<IInterface*> FindAll(std::string_view name, u32 version) = 0;

  template <typename T>
  T* Get() {
    return static_cast<T*>(Find(T::kInterface.name, T::kInterface.version));
  }

  template <typename T>
  std::vector<T*> FindAll() {
    std::vector<T*> found;
    for (IInterface* iface : FindAll(T::kInterface.name, T::kInterface.version)) {
      found.push_back(static_cast<T*>(iface));
    }
    return found;
  }
};

REX_DECLARE_INTERFACE(IModule, 2)
  virtual std::string_view GetName() const = 0;

  virtual std::span<const InterfaceType> GetRequiredInterfaces() const { return {}; }

  virtual std::span<const InterfaceType> GetServedInterfaces() const { return {}; }

  [[nodiscard]] virtual Result<void> Connect(IInterfaceFactory& factory) = 0;

  virtual void Disconnect() = 0;

  [[nodiscard]] virtual Result<void> Init() = 0;

  virtual void Shutdown() = 0;

  virtual IInterface* QueryInterface(std::string_view name, u32 version) {
    (void)name;
    (void)version;
    return nullptr;
  }
};

template <typename... Interfaces, typename Module>
IInterface* FindModuleInterface(Module& module, std::string_view name, u32 version) {
  IInterface* found = nullptr;
  ((!found && name == Interfaces::kInterface.name && version == Interfaces::kInterface.version
        ? (found = static_cast<Interfaces*>(&module))
        : nullptr),
   ...);
  return found;
}
 
namespace detail {

REX_API IInterfaceFactory* GetAppInterfaceFactory();
 
}  // namespace detail

class AppInterfaces {
 public:
  template <typename T>
  static T* Get() {
    IInterfaceFactory* factory = detail::GetAppInterfaceFactory();
    return factory ? factory->Get<T>() : nullptr;
  }
};
 
#define REX_INTERFACE(T) ::rex::AppInterfaces::Get<T>()

inline constexpr const char* kCreateInterfaceSymbol = "ReXCreateInterface";

inline constexpr const char* kEnumerateInterfacesSymbol = "ReXEnumerateInterfaces";

inline constexpr const char* kBuildIdentitySymbol = "ReXBuildIdentity";

using CreateInterfaceFn = IInterface* (*)(const char* name, u32 version);

using EnumerateInterfacesFn = u32 (*)(InterfaceType* out, u32 capacity);
 
namespace detail {

template <typename... Interfaces>
struct ServedTypeList {
  static constexpr InterfaceType kList[] = {Interfaces::kInterface...};
};

inline std::vector<InterfaceType> ListServedInterfaces(const IModule& module) {
  std::vector<InterfaceType> types{IModule::kInterface};
  for (const InterfaceType& type : module.GetServedInterfaces()) {
    if (std::string_view(type.name) != IModule::kInterface.name) {
      types.push_back(type);
    }
  }
  return types;
}
 
template <typename Module>
IInterface* CreateModuleInterface(Module& module, std::string_view name, u32 version) {
  if (name == IModule::kInterface.name && version == IModule::kInterface.version) {
    return static_cast<IModule*>(&module);
  }
  return module.QueryInterface(name, version);
}
 
inline u32 EnumerateModuleInterfaces(const IModule& module, InterfaceType* out, u32 capacity) {
  const std::vector<InterfaceType> types = ListServedInterfaces(module);
  const u32 count = static_cast<u32>(types.size());
  for (u32 i = 0; i < count && i < capacity; ++i) {
    out[i] = types[i];
  }
  return count;
}
 
}  // namespace detail
}  // namespace rex

#define REX_MODULE_SERVES(...)                                                   \
  ::std::span<const ::rex::InterfaceType> GetServedInterfaces() const override { \
    return ::rex::detail::ServedTypeList<__VA_ARGS__>::kList;                    \
  }

#define REX_DECLARE_MODULE(ModuleClass)                                                           \
  namespace {                                                                                     \
  using ReXModuleType = ModuleClass;                                                              \
  ReXModuleType& ReXModuleInstance() {                                                            \
    static ModuleClass instance;                                                                  \
    return instance;                                                                              \
  }                                                                                               \
  }                                                                                               \
  extern "C" REX_DETAIL_EXPORT const char* ReXBuildIdentity() {                                   \
    return REXGLUE_BUILD_IDENTITY;                                                                \
  }                                                                                               \
  extern "C" REX_DETAIL_EXPORT ::rex::IInterface* ReXCreateInterface(const char* name,            \
                                                                     ::rex::u32 version) {        \
    return ::rex::detail::CreateModuleInterface<ModuleClass>(ReXModuleInstance(), name, version); \
  }                                                                                               \
  extern "C" REX_DETAIL_EXPORT ::rex::u32 ReXEnumerateInterfaces(::rex::InterfaceType* out,       \
                                                                 ::rex::u32 capacity) {           \
    return ::rex::detail::EnumerateModuleInterfaces(ReXModuleInstance(), out, capacity);          \
  }