Changeset 10547 for code/branches/core7/src/libraries

Timestamp:

Aug 23, 2015, 11:57:53 AM (9 years ago)

Author:

landauf

Message:

added support for plugins in the buildsystem. plugins are like modules, but can be loaded/unloaded at runtime

Location:

code/branches/core7/src/libraries/core

Files:

• ApplicationPaths.cc (modified) (8 diffs)
• ApplicationPaths.h (modified) (6 diffs)
• Core.cc (modified) (1 diff)

code/branches/core7/src/libraries/core/ApplicationPaths.cc

@@ -74 +74 @@
         , executablePath_(*(new bf::path()))
         , modulePath_(*(new bf::path()))
+        , pluginPath_(*(new bf::path()))
         , bBuildDirectoryRun_(false)
     {
@@ -121 +122 @@
         executablePath_ = bf::path(buffer).branch_path();
 
-        /////////////////////
-        // SET MODULE PATH //
-        /////////////////////
+        /////////////////////////////////
+        // SET MODULE AND PLUGIN PATHS //
+        /////////////////////////////////
 
         if (bf::exists(executablePath_ / "orxonox_dev_build.keep_me"))
@@ -130 +131 @@
             ApplicationPaths::bBuildDirectoryRun_ = true;
             modulePath_ = specialConfig::moduleDevDirectory;
+            pluginPath_ = specialConfig::pluginDevDirectory;
         }
         else
@@ -144 +146 @@
                 ThrowException(General, "Could not derive a root directory. Might the binary installation directory contain '..' when taken relative to the installation prefix path?");
 
-            // Module path is fixed as well
+            // Module and plugin paths are fixed as well
             modulePath_ = rootPath_ / specialConfig::defaultModulePath;
+            pluginPath_ = rootPath_ / specialConfig::defaultPluginPath;
 
 #else
 
             // There is no root path, so don't set it at all
-            // Module path is fixed as well
+            // Module and plugin paths are fixed as well
             modulePath_ = specialConfig::moduleInstallDirectory;
+            pluginPath_ = specialConfig::pluginInstallDirectory;
 
 #endif
@@ -162 +166 @@
         delete &executablePath_;
         delete &modulePath_;
+        delete &pluginPath_;
     }
 
     std::vector<std::string> ApplicationPaths::getModulePaths()
     {
-        std::vector<std::string> modulePaths;
+        return this->getModuleOrPluginPaths(modulePath_, specialConfig::moduleExtension);
+    }
+
+    std::vector<std::string> ApplicationPaths::getPluginPaths()
+    {
+        return this->getModuleOrPluginPaths(pluginPath_, specialConfig::pluginExtension);
+    }
+
+    std::vector<std::string> ApplicationPaths::getModuleOrPluginPaths(boost::filesystem::path& directory, const std::string& extension)
+    {
+        std::vector<std::string> paths;
 
         // We search for helper files with the following extension
-        const std::string& moduleextension = specialConfig::moduleExtension;
-        size_t moduleextensionlength = moduleextension.size();
-
-        // Make sure the path exists, otherwise don't load modules
-        if (!boost::filesystem::exists(modulePath_))
-            return modulePaths;
-
-        boost::filesystem::directory_iterator file(modulePath_);
+        size_t extensionlength = extension.size();
+
+        // Make sure the path exists, otherwise don't load modules/plugins
+        if (!boost::filesystem::exists(directory))
+            return paths;
+
+        boost::filesystem::directory_iterator file(directory);
         boost::filesystem::directory_iterator end;
 
@@ -185 +199 @@
 
             // Check if the file ends with the extension in question
-            if (filename.size() > moduleextensionlength)
+            if (filename.size() > extensionlength)
             {
-                if (filename.substr(filename.size() - moduleextensionlength) == moduleextension)
+                if (filename.substr(filename.size() - extensionlength) == extension)
                 {
                     // We've found a helper file
-                    const std::string& library = filename.substr(0, filename.size() - moduleextensionlength);
-                    modulePaths.push_back(getModulePathString() + library);
+                    const std::string& library = filename.substr(0, filename.size() - extensionlength);
+                    paths.push_back(directory.BF_GENERIC_STRING() + '/' + library);
                 }
             }
@@ -197 +211 @@
         }
 
-        return modulePaths;
+        return paths;
     }
 
@@ -214 +228 @@
         return getInstance().modulePath_.BF_GENERIC_STRING() + '/';
     }
+
+    /*static*/ std::string ApplicationPaths::getPluginPathString()
+    {
+        return getInstance().pluginPath_.BF_GENERIC_STRING() + '/';
+    }
 }

code/branches/core7/src/libraries/core/ApplicationPaths.h

@@ -49 +49 @@
         The ApplicationPaths class is a singleton which provides static paths of the application.
     @details
-        The class provides information about the executable, root and module path.
+        The class provides information about the executable, root and module/plugin path.
         It determines those by the use of platform specific functions.
     @remarks
@@ -63 +63 @@
             /**
             @brief
-                Retrieves the executable path and sets all hard coded fixed paths (currently only the module path)
+                Retrieves the executable path and sets all hard coded fixed paths (currently only the module and the plugin paths)
                 Also checks for "orxonox_dev_build.keep_me" in the executable directory.
                 If found it means that this is not an installed run, hence we
@@ -82 +82 @@
             static const boost::filesystem::path& getModulePath()
                 { return getInstance().modulePath_; }
+            //! Returns the path to the plugins as boost::filesystem::path
+            static const boost::filesystem::path& getPluginPath()
+                { return getInstance().pluginPath_; }
 
             //! Returns the path to the root folder as std::string
@@ -89 +92 @@
             //! Returns the path to the modules as std::string
             static std::string getModulePathString();
+            //! Returns the path to the plugins as std::string
+            static std::string getPluginPathString();
 
             //! Return true for runs in the build directory (not installed)
@@ -95 +100 @@
             //! Returns a list with all modules declared by a *.module file in the module folder.
             std::vector<std::string> getModulePaths();
+            //! Returns a list with all plugins declared by a *.plugin file in the plugin folder.
+            std::vector<std::string> getPluginPaths();
 
         private:
             ApplicationPaths(const ApplicationPaths&); //!< Don't use (undefined symbol)
+
+            std::vector<std::string> getModuleOrPluginPaths(boost::filesystem::path& directory, const std::string& extension);
 
             //! Path to the parent directory of the ones above if program was installed with relative paths
@@ -103 +112 @@
             boost::filesystem::path& executablePath_;        //!< Path to the executable
             boost::filesystem::path& modulePath_;            //!< Path to the modules
+            boost::filesystem::path& pluginPath_;            //!< Path to the plugins
 
             bool                     bBuildDirectoryRun_;    //!< True for runs in the build directory (not installed)

code/branches/core7/src/libraries/core/Core.cc

@@ -142 +142 @@
         orxout(internal_info) << "Executable path: " << ApplicationPaths::getExecutablePathString() << endl;
         orxout(internal_info) << "Modules path:    " << ApplicationPaths::getModulePathString() << endl;
+        orxout(internal_info) << "Plugins path:    " << ApplicationPaths::getPluginPathString() << endl;
 
         orxout(internal_info) << "Data path:       " << ConfigurablePaths::getDataPathString() << endl;