GyotoRegister.h

Go to the documentation of this file.

/*
    Copyright 2011-2025 Thibaut Paumard

    This file is part of Gyoto.

    Gyoto is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Gyoto is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Gyoto.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __GyotoRegister_H_
#define __GyotoRegister_H_

#include <string>
#include <glob.h>
#include <filesystem>
#include "GyotoSmartPointer.h"

namespace Gyoto {
  namespace Register {

    /* Documented below */
    class Entry;

    void init( char const * pluglist = NULL );

    void list();
  }

  void * loadPlugin(   char const * const plugname, int nofail = 0);

  bool havePlugin(std::string plugname);

  void requirePlugin(std::string plugname, int nofail = 0);

  std::vector<std::string> pluginPath();

  void pluginPath(const std::vector<std::string> &v);

}

class Gyoto::Register::Entry {
  friend void Gyoto::Register::list();
protected:
  std::string name_;
  Gyoto::SmartPointee::Subcontractor_t* subcontractor_;
  Register::Entry* next_;
  const std::string plugin_;
public:
  Entry(std::string name,
                Gyoto::SmartPointee::Subcontractor_t* subcontractor,
                Entry* next);
  ~Entry(); 

  Gyoto::SmartPointee::Subcontractor_t*
    getSubcontractor(std::string name, std::string &plugin, int errmode=0);

  std::string name();

  std::string plugin();

  Register::Entry* next();
};

#define GYOTO_GETSUBCONTRACTOR(space)                                   \
  Gyoto::space::Subcontractor_t*                                        \
  Gyoto::space::getSubcontractor(std::string name,                      \
                                 std::vector<std::string> &plugin,      \
                                 int errmode) {                         \
    std::vector<std::string> mandatory;                                 \
    std::vector<std::string> fallback;                                  \
    std::vector<std::string> plug_path(Gyoto::pluginPath());            \
    GYOTO_DEBUG << "loading non-fallback plug-ins..." << std::endl;     \
    for (const auto &plg : plugin) {                                    \
      GYOTO_DEBUG_EXPR(plg);                                            \
      if (plg.rfind("fallback:", 0) != 0) {                             \
        Gyoto::requirePlugin(plg);                                      \
        mandatory.emplace_back(plg);                                    \
      }                                                                 \
      else fallback.emplace_back(plg.substr(9));                        \
    }                                                                   \
    GYOTO_DEBUG << "found " << mandatory.size()                         \
                << " mandatory plg-ins and "<< fallback.size()          \
                << " fallback plug-ins" << std::endl;                   \
    GYOTO_DEBUG <<                                                      \
      "loading fallback plug-ins until the Register is not empty"       \
                << std::endl;                                           \
    for (const auto plg : fallback) {                                   \
      if (Gyoto::space::Register_) break;                               \
      GYOTO_DEBUG_EXPR(plg);                                            \
      Gyoto::requirePlugin(plg, 2);                                     \
    }                                                                   \
    for (const auto &plg : fallback) {                                  \
      if (Gyoto::space::Register_) break;                               \
      GYOTO_DEBUG_EXPR(plg);                                            \
      for (const auto &path : plug_path) {                              \
        std::string pattern = (path + "libgyoto-" + plg)                \
                     + "." GYOTO_PLUGIN_SFX;                            \
        std::vector<std::string> files =                                \
          Gyoto::glob(pattern);                                         \
        for (const auto &file : files) {                                \
          GYOTO_DEBUG << "Trying " << file << std::endl;                \
          Gyoto::requirePlugin(file, 2);                                \
        }                                                               \
      }                                                                 \
    }                                                                   \
    if (!Gyoto::space::Register_)                                       \
      throwError("No " GYOTO_STRINGIFY(space) " kind registered!");     \
    Gyoto::space::Subcontractor_t* sctr= NULL;                          \
    GYOTO_DEBUG << "looking for " << name                               \
                << " in non-fallback plug-ins..."  << std::endl;        \
    for (auto & plg : mandatory) {                                      \
      GYOTO_DEBUG_EXPR(plg);                                            \
      sctr=(Gyoto::space::Subcontractor_t*)Gyoto::space::Register_      \
        -> getSubcontractor(name, plg, 2);                              \
      if (sctr) {                                                       \
        GYOTO_DEBUG << "found " << name << " in plug-in "               \
                    << plg << std::endl;                                \
        return sctr;                                                    \
      }                                                                 \
    }                                                                   \
    if (!mandatory.size()) {                                            \
      GYOTO_DEBUG << "looking for " << name                             \
                  << " in registered plug-ins..."  << std::endl;        \
      std::string plg("");                                              \
      sctr = (Gyoto::space::Subcontractor_t*)Gyoto::space::Register_    \
        -> getSubcontractor(name, plg, 2);                              \
      if (sctr){                                                        \
        GYOTO_DEBUG << "found " << name << " in plug-in "               \
                    << plg << std::endl;                                \
        plugin.emplace(plugin.begin(), plg);                            \
        GYOTO_DEBUG << "added '" << plugin[0]                           \
                    << "' as item 0 of pluglist" << std::endl;          \
        return sctr;                                                    \
      } else if (!fallback.size() && !errmode)                          \
        throwError ("Kind not found in any plug-in: "+name);            \
    }                                                                   \
    GYOTO_DEBUG << "looking for " << name                               \
                << " in fallback plug-ins..."  << std::endl;            \
    /* try to load fallbacks directly */                                \
    for (auto &plg : fallback) {                                        \
      GYOTO_DEBUG_EXPR(plg);                                            \
      Gyoto::requirePlugin(plg, 2);                                     \
      sctr = (Gyoto::space::Subcontractor_t*)Gyoto::space::Register_    \
        -> getSubcontractor(name, plg, 2);                              \
      if (sctr) {                                                       \
        GYOTO_DEBUG << "found " << name << " in plug-in "               \
                    << plg << std::endl;                                \
        return sctr;                                                    \
      }                                                                 \
    }                                                                   \
    GYOTO_DEBUG << "looking for " << name                               \
                << " in fallback plug-ins, "                            \
                << "allowing for glob expansion..."  << std::endl;      \
    for (const auto &plg : fallback) {                                  \
      /* try glob expansion on plg itself, may it is already a path     \
         with wildcards */                                              \
      GYOTO_DEBUG_EXPR(plg);                                            \
      std::vector<std::string> files = Gyoto::glob(plg);                \
      for (auto &file : files) {                                        \
        GYOTO_DEBUG << "Trying " << file << std::endl;                  \
        if (!std::filesystem::exists(file)) continue;                   \
        Gyoto::requirePlugin(file, 2);                                  \
        sctr = (Gyoto::space::Subcontractor_t*)Gyoto::space::Register_  \
          -> getSubcontractor(name, file, 2);                           \
        if (sctr) {                                                     \
          GYOTO_DEBUG << "found " << name << " in plug-in "             \
                      << file << std::endl;                             \
          return sctr;                                                  \
        }                                                               \
      }                                                                 \
      /* try glob expansion on <directory>/libgyoto-<plg>.so for every  \
         directory in the plug-in path */                               \
      for (const auto &path : plug_path) {                              \
        std::string pattern = (path + "libgyoto-" + plg)                \
                     + "." GYOTO_PLUGIN_SFX;                            \
        files = Gyoto::glob(pattern);                                   \
        for (auto &file : files) {                                      \
          GYOTO_DEBUG << "Trying " << file << std::endl;                \
          if (!std::filesystem::exists(file)) continue;                 \
          Gyoto::requirePlugin(file, 2);                                \
          sctr=(Gyoto::space::Subcontractor_t*)Gyoto::space::Register_  \
            -> getSubcontractor(name, file, 2);                         \
          if (sctr) {                                                   \
            GYOTO_DEBUG << "found " << name << " in plug-in "           \
                        << file << std::endl;                           \
            return sctr;                                                \
          }                                                             \
        }                                                               \
      }                                                                 \
    }                                                                   \
    GYOTO_DEBUG << name << " not found anywhere, error?"                \
                << std::endl;                                           \
    if (!errmode)                                                       \
      throwError("Kind not found in the specified plug-ins: "+name);    \
    return sctr;                                                        \
  }

#endif