VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule Class Reference

Inheritance diagram for VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule:

Collaboration diagram for VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule:

Public Member Functions
template<typename T >
T	getFunctionPointer (const char *name)
	~LinuxModule () override
bool	load (const std::string &inPath, std::string &errorDescription) override
Public Member Functions inherited from Module
	Module (const FilePath &name)
virtual	~Module ()
void	ShowLoadFailureError (const wxString &Error)
bool	Load (wxString &deferredErrorMessage)
void	Unload ()
bool	HasDispatch ()
int	Dispatch (ModuleDispatchTypes type)
void *	GetSymbol (const wxString &name)
const FilePath &	GetName () const

Static Public Member Functions
static Optional< Path >	getSOPath (const std::string &inPath)

Public Attributes
void *	mModule {nullptr}

Detailed Description

Definition at line 116 of file module_linux.cpp.

Constructor & Destructor Documentation

~LinuxModule()

VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule::~LinuxModule ( )

inlineoverride

Definition at line 125 of file module_linux.cpp.

   {
      factory = PluginFactory (nullptr);
 
      if (mModule)
      {
         if (auto moduleExit = getFunctionPointer<ModuleExitFunc> ("ModuleExit"))
            moduleExit ();
 
         dlclose (mModule);
      }
   }

References factory.

Member Function Documentation

getFunctionPointer()

template<typename T >

T VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule::getFunctionPointer ( const char *  name )

inline

Definition at line 120 of file module_linux.cpp.

   {
      return reinterpret_cast<T> (dlsym (mModule, name));
   }

References name.

getSOPath()

static Optional< Path > VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule::getSOPath ( const std::string &  inPath )

inlinestatic

Definition at line 138 of file module_linux.cpp.

   {
      Path modulePath {inPath};
      if (!filesystem::is_directory (modulePath))
         return {};
 
      auto stem = modulePath.stem ();
 
      modulePath /= "Contents";
      if (!filesystem::is_directory (modulePath))
         return {};
 
      // use the Machine Hardware Name (from uname cmd-line) as prefix for "-linux"
      auto machine = getCurrentMachineName ();
      if (!machine)
         return {};
 
      modulePath /= *machine + "-linux";
      if (!filesystem::is_directory (modulePath))
         return {};
 
      stem.replace_extension (".so");
      modulePath /= stem;
      return Optional<Path> (std::move (modulePath));
   }

References VST3::Hosting::anonymous_namespace{module_linux.cpp}::getCurrentMachineName().

Here is the call graph for this function:

load()

bool VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule::load ( const std::string &  inPath, std::string &  errorDescription  )

inlineoverride

Definition at line 164 of file module_linux.cpp.

   {
      auto modulePath = getSOPath (inPath);
      if (!modulePath)
      {
         errorDescription = inPath + " is not a module directory.";
         return false;
      }
 
      mModule = dlopen (reinterpret_cast<const char*> (modulePath->generic_string ().data ()),
                        RTLD_LAZY);
      if (!mModule)
      {
         errorDescription = "dlopen failed.\n";
         errorDescription += dlerror ();
         return false;
      }
      // ModuleEntry is mandatory
      auto moduleEntry = getFunctionPointer<ModuleEntryFunc> ("ModuleEntry");
      if (!moduleEntry)
      {
         errorDescription =
             "The shared library does not export the required 'ModuleEntry' function";
         return false;
      }
      // ModuleExit is mandatory
      auto moduleExit = getFunctionPointer<ModuleExitFunc> ("ModuleExit");
      if (!moduleExit)
      {
         errorDescription =
             "The shared library does not export the required 'ModuleExit' function";
         return false;
      }
      auto factoryProc = getFunctionPointer<GetFactoryProc> ("GetPluginFactory");
      if (!factoryProc)
      {
         errorDescription =
             "The shared library does not export the required 'GetPluginFactory' function";
         return false;
      }
 
      if (!moduleEntry (mModule))
      {
         errorDescription = "Calling 'ModuleEntry' failed";
         return false;
      }
      auto f = Steinberg::FUnknownPtr<Steinberg::IPluginFactory> (owned (factoryProc ()));
      if (!f)
      {
         errorDescription = "Calling 'GetPluginFactory' returned nullptr";
         return false;
      }
      factory = PluginFactory (f);
      return true;
   }

References factory.

Member Data Documentation

mModule

void* VST3::Hosting::anonymous_namespace{module_linux.cpp}::LinuxModule::mModule {nullptr}

Definition at line 220 of file module_linux.cpp.

---

The documentation for this class was generated from the following file:

• module_linux.cpp