Manager.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/Logger.h>
 
#include <string>
#include <map>
#include <vector>
#include <functional>
#include <memory>
#include <variant>
 
namespace Belle2 {
  class Particle;
  class ParticleList;
 
  namespace Variable {
    class Manager {
 
    public:
      typedef std::variant<double, int, bool> VarVariant;
      typedef std::function<VarVariant(const Particle*)> FunctionPtr;
      typedef std::function<VarVariant(const Particle*, const std::vector<double>&)> ParameterFunctionPtr;
      typedef std::function<FunctionPtr(const std::vector<std::string>&)> MetaFunctionPtr;
      typedef Particle Object;

      enum VariableDataType {
        c_double = 0,
        c_int    = 1,
        c_bool   = 2
      };

      struct VarBase {
        std::string name; 
        std::string description; 
        std::string group; 
        VariableDataType variabletype; 
        std::string functionName; 
        VarBase(const std::string& n, const std::string& d, const std::string& g, const VariableDataType& v, const std::string& fName = "")
          : name(n), description(d), group(g), variabletype(v), functionName(fName.empty() ? n : fName) { }

        void extendDescriptionString(const std::string& d)
        {
          description.append(d);
        }
      };

      struct Var : public VarBase {
        FunctionPtr function; 
        Var(const std::string& n, FunctionPtr f, const std::string& d, const std::string& g = "",
            const VariableDataType& v = VariableDataType::c_double, const std::string& fName = "")
          : VarBase(n, d, g, v, fName), function(f) { }
      };

      struct ParameterVar : public VarBase {
        ParameterFunctionPtr function; 
        ParameterVar(const std::string& n, ParameterFunctionPtr f, const std::string& d, const std::string& g = "",
                     const VariableDataType& v = VariableDataType::c_double, const std::string& fName = "")
          : VarBase(n, d, g, v, fName), function(f) { }
      };

      struct MetaVar : public VarBase {
        MetaFunctionPtr function; 
        explicit MetaVar(const std::string& n, MetaFunctionPtr f, const std::string& d, const std::string& g = "",
                         const VariableDataType& v = VariableDataType::c_double, const std::string& fName = "")
          : VarBase(n, d, g, v, fName), function(f) { }
      };

      static Manager& Instance();

      const Var* getVariable(std::string name);

      const Var* getVariable(const std::string& functionName, const std::vector<std::string>& functionArguments);

      std::vector<const Variable::Manager::Var*> getVariables(const std::vector<std::string>& variables);

      bool addAlias(const std::string& alias, const std::string& variable);

      void printAliases();

      void clearAliases();

      std::string resolveAlias(const std::string& alias);

      bool addCollection(const std::string& collection, const std::vector<std::string>& variables);

      std::vector<std::string> getCollection(const std::string& collection);

      std::vector<std::string> resolveCollections(const std::vector<std::string>& variables);

      std::vector<const Variable::Manager::VarBase*> getVariables() const { return m_variablesInRegistrationOrder; }
 

      void setVariableGroup(const std::string& groupName);

      void registerVariable(const std::string& name, const Manager::FunctionPtr& f, const std::string& description,
                            const Manager::VariableDataType& v, const std::string& unit = "", const std::string& fName = "");
      void registerVariable(const std::string& name, const Manager::ParameterFunctionPtr& f, const std::string& description,
                            const Manager::VariableDataType& v, const std::string& unit = "", const std::string& fName = "");
      void registerVariable(const std::string& name, const Manager::MetaFunctionPtr& f, const std::string& description,
                            const Manager::VariableDataType& v, const std::string& fName = "");
      void deprecateVariable(const std::string& name, bool make_fatal, const std::string& version, const std::string& description);

      void checkDeprecatedVariable(const std::string& name);

      double evaluate(const std::string& varName, const Particle* p);

      std::vector<double> evaluateVariables(const std::vector<std::string>& varNames, const ParticleList* plist);

      std::vector<std::string> getNames() const;

      std::vector<std::string> getAliasNames() const;

      void assertValidName(const std::string& name);
 
    private:
      Manager() {};
      Manager(const Manager&);
      ~Manager();

      bool createVariable(const std::string& name);

      bool createVariable(const std::string& fullname, const std::string& functionName,
                          const std::vector<std::string>& functionArguments);

      std::string m_currentGroup;

      std::vector<const VarBase*> m_variablesInRegistrationOrder;

      std::map<std::string, std::string> m_alias;
      std::map<std::string, std::vector<std::string>> m_collection;
      std::map<std::string, std::shared_ptr<Var>> m_variables;
      std::map<std::string, std::shared_ptr<ParameterVar>> m_parameter_variables;
      std::map<std::string, std::shared_ptr<MetaVar>> m_meta_variables;
      std::map<std::string, std::pair<bool, std::string>> m_deprecated;
    };

    class Proxy {
    public:
      Proxy(const std::string& name, Manager::FunctionPtr f, const std::string& description, Manager::VariableDataType v,
            const std::string& unit = "", const std::string& fName = "")
      {
        Manager::Instance().registerVariable(name, f, description, v, unit, fName);
      }

      Proxy(const std::string& name, Manager::ParameterFunctionPtr f, const std::string& description, Manager::VariableDataType v,
            const std::string& unit = "", const std::string& fName = "")
      {
        Manager::Instance().registerVariable(name, f, description, v, unit, fName);
      }

      Proxy(const std::string& name, Manager::MetaFunctionPtr f, const std::string& description, Manager::VariableDataType v,
            const std::string& fName = "")
      {
        Manager::Instance().registerVariable(name, f, description, v, fName);
      }
    };

    class GroupProxy {
    public:
      explicit GroupProxy(const std::string& groupName)
      {
        Manager::Instance().setVariableGroup(groupName);
      }
    };

    class DeprecateProxy {
    public:
      DeprecateProxy(const std::string& name, bool make_fatal, const std::string& version, const std::string& description)
      {
        Manager::Instance().deprecateVariable(name, make_fatal, version, description);
      }
    };
 
    template<typename T>
    std::function<T> make_function(T* t)
    {
      return { t };
    }
 
    template<typename T>
    Variable::Manager::VariableDataType get_function_type(const std::string& name, T* t)
    {
      auto func =  std::function{t};
      using ReturnType = typename decltype(func)::result_type;
      if (std::is_same_v<ReturnType, double>) {
        return Variable::Manager::VariableDataType::c_double;
      } else if (std::is_same_v<ReturnType, int>) {
        return Variable::Manager::VariableDataType::c_int;
      } else if (std::is_same_v<ReturnType, bool>) {
        return Variable::Manager::VariableDataType::c_bool;
      } else {
        B2FATAL("Metavariables must be registered using the REGISTER_METAVARIABLE macro." << LogVar("Variablename", name));
      }
    }

#define VARMANAGER_CONCATENATE_DETAIL(x, y) x##y
#define VARMANAGER_CONCATENATE(x, y) VARMANAGER_CONCATENATE_DETAIL(x, y)
#define VARMANAGER_MAKE_UNIQUE(x) VARMANAGER_CONCATENATE(x, __LINE__)

#define REGISTER_VARIABLE_NO_UNIT(name, function, description) \
  static Proxy VARMANAGER_MAKE_UNIQUE(_variableproxy)(std::string(name), \
                                                      Variable::make_function(function), std::string(description), \
                                                      Variable::get_function_type(name,function), std::string(""), std::string(#function));

#define REGISTER_VARIABLE_WITH_UNIT(name, function, description, unit) \
  static Proxy VARMANAGER_MAKE_UNIQUE(_variableproxy)(std::string(name), \
                                                      Variable::make_function(function), std::string(description), \
                                                      Variable::get_function_type(name,function), std::string(unit), std::string(#function));

#define PICK_FIFTH_ARG(arg1, arg2, arg3, arg4, arg5, ...) arg5

#define REGISTER_VARIABLE_MACRO_CHOOSER(...) PICK_FIFTH_ARG(__VA_ARGS__, REGISTER_VARIABLE_WITH_UNIT, REGISTER_VARIABLE_NO_UNIT, )

#define REGISTER_VARIABLE(...) REGISTER_VARIABLE_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

#define REGISTER_METAVARIABLE(name, function, description, variabledatatype) \
  static Proxy VARMANAGER_MAKE_UNIQUE(_variableproxy)(std::string(name), \
                                                      Variable::make_function(function), std::string(description), \
                                                      Variable::Manager::VariableDataType(variabledatatype), std::string(#function));

#define VARIABLE_GROUP(groupName) \
  static GroupProxy VARMANAGER_MAKE_UNIQUE(_variablegroupproxy)(groupName);
 
  }
#define MAKE_DEPRECATED(name, make_fatal, version, description) \
  static DeprecateProxy VARMANAGER_MAKE_UNIQUE(_deprecateproxy)(std::string(name),  bool(make_fatal), std::string(version), std::string(description));

}