UserPlugin.hpp

Go to the documentation of this file.

#ifndef STK_UTIL_DIAG_UserPlugin_h
#define STK_UTIL_DIAG_UserPlugin_h

#include <memory>
#include <map>
#include <vector>
#include <string>
#include <typeinfo>

#include <stk_util/diag/StringUtil.hpp>
#include <stk_util/util/Fortran.hpp>
#include <stk_util/diag/Writer_fwd.hpp>

namespace sierra {
namespace Plugin {

std::string derived_id_name(int derived_id);

class Registry
{
public:

  typedef std::pair<const std::type_info *, std::string> NamePair;

//   /**
//    * @brief Class <b>hash_nocase</b> implements a hash, case insensitive NamePair
//    * hash functor.
//    *
//    */
//   struct hash_nocase
//   {
//     size_t operator()(const NamePair &n) const {
//       return sierra::hash_string_nocase(n.second.c_str());
//     }
//   };

//   /**
//    * @brief Class <b>hash_nocase</b> implements a hash, case insensitive compare
//    * equal NamePair functor.
//    *
//    */
//   struct equal_nocase : public std::binary_function<NamePair, NamePair, bool>
//   {
//     bool operator()(const NamePair &lhs, const NamePair &rhs) const {
//       sierra::equal_nocase<NamePair::second_type> second_equal_nocase;

//       return *lhs.first == *rhs.first && second_equal_nocase(lhs.second, rhs.second);
//     }
//   };

  struct less_nocase : public std::binary_function<NamePair, NamePair, bool>
  {
    bool operator()(const NamePair &lhs, const NamePair &rhs) const {
      sierra::less_nocase<NamePair::second_type> second_less_nocase;

#ifdef SIERRA_TYPE_INFO_BEFORE_EQUALITY_BUG
      return (lhs.first->before(*rhs.first) && *lhs.first != *rhs.first)
  || (*lhs.first == *rhs.first && second_less_nocase(lhs.second, rhs.second));
#else
      return lhs.first->before(*rhs.first)
  || (*lhs.first == *rhs.first && second_less_nocase(lhs.second, rhs.second));
#endif
    }
  };

  typedef std::map<NamePair, void *, less_nocase> RegistryMap;

  static RegistryMap &getRegistryMap();

  Registry()
  {}

  explicit Registry(const NamePair &name_pair) {
    registerIt(name_pair, this);
  }

  virtual ~Registry()
  {}

  static Registry &rootInstance();

  static void registerDL(const char *so_path, const char *function_name = 0);

  template <typename T>
  static T getsym(const char *sym);

  void registerIt(const NamePair &name_pair, void *func_ptr);

  void *getPluginPtr(const NamePair &name_pair) const;

  void *getFunctionPtr(const NamePair &name_pair) const;

  Registry *getFactoryPtr(const NamePair &name) const;

  void *getFuncPtr(const NamePair &name_pair) const;

  std::vector<std::string> getDerivedNames(const std::type_info &type) const;

  template<class T>
  static T &create(const std::string &derived_name) {
    return static_cast<T &>(*Registry::rootInstance().getFactoryPtr(std::make_pair(&typeid(T), derived_name)));
  }

  std::ostream &verbose_print(std::ostream &os) const;

  stk_classic::diag::Writer &verbose_print(stk_classic::diag::Writer &dout) const;
};

inline stk_classic::diag::Writer &operator<<(stk_classic::diag::Writer &dout, const Registry &registry) {
  return registry.verbose_print(dout);
}


template <class Creator, typename S = Creator *(*)()>
class UserPlugin
{
public:
  typedef S Signature;          

private:
  UserPlugin();           
  UserPlugin(const UserPlugin&);      
  UserPlugin &operator=(const UserPlugin&);   

public:
  static UserPlugin &instance() {
    return (UserPlugin<Creator, Signature> &) (Registry::rootInstance());
  }

  static void registerCreator(const std::string &derived_name, Signature function) {
    Registry::rootInstance().registerIt(std::make_pair(&typeid(Signature), derived_name), (void *) function);
  }

  static Signature create(const std::string &derived_name) {
    Signature creator_function = (Signature) Registry::rootInstance().getPluginPtr(std::make_pair(&typeid(Signature), derived_name));

    return (*creator_function);
  }

  static Signature create(int derived_id) {
    return create(derived_id_name(derived_id));
  }

  static bool exists(const std::string &derived_name) {
    return Registry::rootInstance().getFuncPtr(std::make_pair(&typeid(Signature), derived_name)) != NULL;
  }

  static std::vector<std::string> getDerivedNames() {
    return Registry::rootInstance().getDerivedNames(typeid(Signature));
  }

  template <class DerivedClass>
  class Register
  {
  public:
    typedef DerivedClass XDerivedClass;

    explicit Register(const std::string &derived_name)
      : m_function(DerivedClass::createInstance)
    {
      UserPlugin<Creator, Signature>::instance().registerCreator(derived_name, m_function);
    }

    Register(const std::string &derived_name, Signature create_instance)
      : m_function(create_instance)
    {
      UserPlugin<Creator, Signature>::instance().registerCreator(derived_name, m_function);
    }

    explicit Register(int derived_id)
      : m_function(XDerivedClass::createInstance)
    {
      UserPlugin<Creator, Signature>::instance().registerCreator(derived_id_name(derived_id), m_function);
    }

    Register(int derived_id, Signature create_instance)
      : m_function(create_instance)
    {
      UserPlugin<Creator, Signature>::instance().registerCreator(derived_id_name(derived_id), m_function);
    }

  private:
    Signature   m_function;     
  };
};


template <class S>
class UserSubroutine
{
private:
  UserSubroutine();         
  UserSubroutine(const UserSubroutine&);    
  UserSubroutine &operator=(const UserSubroutine&); 

public:
  typedef S Signature;          

  inline static UserSubroutine &instance() {
    return (UserSubroutine<Signature> &) (Registry::rootInstance());
  }

  inline static void registerFunction(const std::string &function_name, Signature *function) {
    Registry::rootInstance().registerIt(std::make_pair(&typeid(Signature), function_name), (void *) function);
  }

  static Signature *execute(const std::string &function_name) {
    Signature *user_function = (Signature *) Registry::rootInstance().getFunctionPtr(std::make_pair(&typeid(Signature), function_name));

    return (*user_function);
  }

  static Signature *getFunction(const std::string &function_name) {
    Signature *user_function = (Signature *) Registry::rootInstance().getFunctionPtr(std::make_pair(&typeid(Signature), function_name));

    return user_function;
  }

  static bool exists(const std::string &derived_name) {
    return Registry::rootInstance().getFuncPtr(std::make_pair(&typeid(Signature), derived_name)) != NULL;
  }

  class Register
  {
  public:
    Register(const std::string &function_name, Signature *function)
      : m_function(function)
    {
      UserSubroutine<Signature>::instance().registerFunction(function_name, *m_function);
    }

  private:
    Signature *   m_function;     
  };
};

template <>
void *Registry::getsym<void *>(const char *sym);

template <typename T>
inline T Registry::getsym(const char *sym) {
  return static_cast<T>(getsym<void *>(sym));
}

} // namespace Plugin
} // namespace sierra

typedef std::type_info *type_info_func();

extern "C" {
  void SIERRA_FORTRAN(register_user_subroutine)(
    type_info_func    type_id,
    void *      user_subroutine,
    const char *    name,
    int       name_length );
}


#define FORTRAN_USER_SUBROUTINE(NAME, USER_SUB) extern "C" const std::type_info * SIERRA_FORTRAN(NAME)() {return &typeid(USER_SUB::Signature);}

#endif // STK_UTIL_DIAG_UserPlugin_h