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 <analysis/DecayDescriptor/DecayDescriptor.h>
 
#include <string>
#include <map>
#include <vector>
#include <functional>
#include <memory>
 
namespace Belle2 {
  class Particle;
 
  namespace Variable {
    class Manager {
    public:
      typedef std::function<double(const Particle*)> FunctionPtr;
      typedef std::function<double(const Particle*, const std::vector<double>&)> ParameterFunctionPtr;
      typedef std::function<FunctionPtr(const std::vector<std::string>&)> MetaFunctionPtr;
      typedef Particle Object;
 
      struct VarBase {
        std::string name; 
        std::string description; 
        std::string group; 
        VarBase(const std::string& n, const std::string& d, const std::string& g)
          : name(n), description(d), group(g) { }
 
        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 = "")
          : VarBase(n, d, g), function(f) { }
      };
 
      struct ParameterVar : public VarBase {
        ParameterFunctionPtr function; 
        ParameterVar(const std::string& n, ParameterFunctionPtr f, const std::string& d, const std::string& g = "")
          : VarBase(n, d, g), function(f) { }
      };
 
      struct MetaVar : public VarBase {
        MetaFunctionPtr function; 
        explicit MetaVar(const std::string& n, MetaFunctionPtr f, const std::string& d, const std::string& g = "")
          : VarBase(n, d, g), function(f) { }
      };
 
      static Manager& Instance();
 
      const Var* getVariable(std::string name);
 
      std::vector<const Belle2::Variable::Manager::Var*> getVariables(const std::vector<std::string>& variables);
 
      bool addAlias(const std::string& alias, const std::string& variable);
 
      void printAliases();
 
      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 Belle2::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);
      void registerVariable(const std::string& name, const Manager::ParameterFunctionPtr& f, const std::string& description);
      void registerVariable(const std::string& name, const Manager::MetaFunctionPtr& f, const std::string& description);
      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<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);
 
      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::Instance().registerVariable(name, f, description);
      }
      Proxy(const std::string& name, Manager::ParameterFunctionPtr f, const std::string& description)
      {
        Manager::Instance().registerVariable(name, f, description);
      }
      Proxy(const std::string& name, Manager::MetaFunctionPtr f, const std::string& description)
      {
        Manager::Instance().registerVariable(name, f, description);
      }
    };
 
    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 };
    }
 
 
#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(name, function, description) \
  static Proxy VARMANAGER_MAKE_UNIQUE(_variableproxy)(std::string(name), Belle2::Variable::make_function(function), std::string(description));
 
#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));
}