promesh_registry.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program 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 Lesser General Public License for more details.
 */
 
#ifndef __H__UG_promesh_registry
#define __H__UG_promesh_registry
 
#include <map>
#include <set>
#include <string>
#include <vector>
#include "keys.h"
#include "registry/registry.h"
#include "boost/mpl/assert.hpp"
#include "boost/mpl/contains.hpp"
namespace ug{
namespace promesh{
 
enum RegistryTargets{
  RT_NONE   = 0,
  RT_UGSCRIPT = 1,
  RT_PROMESH  = 1 << 1,
 
  RT_DEFAULT = RT_UGSCRIPT | RT_PROMESH,
  RT_NO_PROMESH = RT_UGSCRIPT,
  RT_NO_UGSCRIPT = RT_PROMESH
};
enum RegistryTargets {…};
 
namespace detail {
 
 
class UG_API ProMeshFunction{
  public:
    ProMeshFunction ( bridge::ExportedFunction* exportedFunction,
              int priority,
              int groupPriority,
              unsigned int target,
              int shortcutKey = 0,
              ModifierKeys modifierKey = MK_NONE)
    :
      m_exportedFunction(exportedFunction),
      m_priority(priority),
      m_groupPriority(groupPriority),
      m_target(target),
      m_shortcutKey(shortcutKey),
      m_modifierKey(modifierKey)
    {}
    ProMeshFunction ( bridge::ExportedFunction* exportedFunction, {…}
 
    bridge::ExportedFunction*
    exported_function()               {return m_exportedFunction;}
 
    const bridge::ExportedFunction*
    exported_function() const           {return m_exportedFunction;}
 
    int priority() const              {return m_priority;}
    int group_priority() const            {return m_groupPriority;}
 
    bool has_target(RegistryTargets t) const    {return (m_target & t) == t;}
 
    bool operator < (const ProMeshFunction& f) const
    {
      if(m_priority != f.priority())
        return m_priority < f.priority();
      if(m_groupPriority != f.group_priority())
        return m_groupPriority < f.group_priority();
      if(m_exportedFunction->group() != f.exported_function()->group())
        return m_exportedFunction->group() < f.exported_function()->group();
      if(m_exportedFunction->name() != f.exported_function()->name())
        return m_exportedFunction->name() < f.exported_function()->name();
      return m_exportedFunction->num_parameter() < f.exported_function()->num_parameter();
    }
    bool operator < (const ProMeshFunction& f) const {…}
 
    int shortcut_key() const          {return m_shortcutKey;}
    ModifierKeys shortcut_modifier_key() const  {return m_modifierKey;}
 
  private:
    bridge::ExportedFunction* m_exportedFunction;
    int             m_priority;
    int             m_groupPriority;
    unsigned int        m_target;
    int             m_shortcutKey;
    ModifierKeys        m_modifierKey;
};
class UG_API ProMeshFunction {…};
 
}// end of namespace detail
namespace detail {…}
 
 
class UG_API ProMeshRegistry{
  public:
    typedef std::multiset<detail::ProMeshFunction>    ProMeshFunctionSet;
    typedef ProMeshFunctionSet::iterator        func_iter_t;
    typedef ProMeshFunctionSet::const_iterator      const_func_iter_t;
 
    ProMeshRegistry(bridge::Registry* reg) : m_reg(reg), m_counter(0) {}
 
    template<typename TFunc>
    ProMeshRegistry& add_function(  std::string funcName,
                    TFunc func,
                    std::string group = "",
                    std::string retValInfos = "",
                    std::string paramInfos = "",
                    std::string tooltip = "",
                    std::string help = "",
                    unsigned int target = RT_DEFAULT,
                    int shortcutKey = 0,
                    ModifierKeys modifyerKey = MK_NONE)
    {
      using namespace bridge;
      ExportedFunction* ef =
        m_reg->add_and_get_function(
              funcName, func, group, retValInfos,
              paramInfos, tooltip, help);
      
      int& groupPriority = m_groupPriority[group];
      if(!groupPriority){
        groupPriority = m_counter;
      }
 
      m_funcSet.insert(
          detail::ProMeshFunction(ef, m_counter, groupPriority,
                      target, shortcutKey, modifyerKey));
      ++m_counter;
      return *this;
    }
    ProMeshRegistry& add_function(  std::string funcName, {…}
 
    template <typename TClass>
    bridge::ExportedClass<TClass>&
    add_class_( std::string className,
                std::string group = "",
                std::string tooltip = "")
    {
      return m_reg->add_class_<TClass>(className, group, tooltip);
    }
    add_class_( std::string className, {…}
 
    template <typename TClass, typename TBaseClass>
    bridge::ExportedClass<TClass>&
    add_class_( std::string className,
                std::string group = "",
                std::string tooltip = "")
    {
      return m_reg->add_class_<TClass, TBaseClass>(className, group, tooltip);
    }
    add_class_( std::string className, {…}
 
    template <typename TClass, typename TBaseClass1, typename TBaseClass2>
    bridge::ExportedClass<TClass>&
    add_class_( std::string className,
                std::string group = "",
                std::string tooltip = "")
    {
      return m_reg->add_class_<TClass, TBaseClass1, TBaseClass2>(
                          className, group, tooltip);
    }
    add_class_( std::string className, {…}
 
    bridge::Registry* registry()        {return m_reg;}
 
 
    func_iter_t functions_begin()       {return m_funcSet.begin();}
    const_func_iter_t functions_begin() const {return m_funcSet.begin();}
    func_iter_t functions_end()         {return m_funcSet.end();}
    const_func_iter_t functions_end() const   {return m_funcSet.end();}
 
  private:
    bridge::Registry*       m_reg;
    ProMeshFunctionSet      m_funcSet;
    int             m_counter;
    std::map<std::string, int>  m_groupPriority;
};
class UG_API ProMeshRegistry {…};
 
 
}// end of namespace
}// end of namespace
 
#endif  //__H__UG_promesh_registry