mapper_hub.hpp

Go to the documentation of this file.

#ifndef MAPPER_HUB_H
#define MAPPER_HUB_H
 
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "observable_ids.hpp"
#include "wcoef_ids.hpp"
#include "wgroup_ids.hpp"
#include "parametertype_ids.hpp"
#include "model_ids.hpp"
#include "wilsonbasis_ids.hpp"
#include "contributiontype_ids.hpp"
#include "masstype_ids.hpp"
#include "scaletype_ids.hpp"
#include "uncertaintytype_ids.hpp"
#include "decay_ids.hpp"
#include "qcdorder_ids.hpp"
 
enum class MapperKind {
    Observable,
    WCoef,
    Group,
    ParameterType,
    Model,
    WilsonBasis,
    ContributionType,
    MassType,
    ScaleType,
    UncertaintyType,
    Decay,
    QCDOrder
};
 
struct IMapperView {
    virtual ~IMapperView() = default;
 
    virtual std::string canonical(std::string_view s) const = 0;
 
    virtual std::vector<std::string> list_all() const = 0;
 
    virtual bool register_custom(std::string canonical,
                                 std::vector<std::string> aliases) = 0;
};
 
template<class Concrete>
struct MapperViewSimple : IMapperView {
    std::string canonical(std::string_view s) const override {
        auto id = Concrete::id_of(s);
        return Concrete::str(id);
    }
 
    std::vector<std::string> list_all() const override {
        std::vector<std::string> out;
        for (auto& id : Concrete::list_all()) {
            out.push_back(Concrete::str(id));
        }
        return out;
    }
 
    bool register_custom(std::string canonical,
                         std::vector<std::string> aliases) override
    {
        return Concrete::register_custom(std::move(canonical), std::move(aliases));
    }
};
 
template<class Concrete>
struct MapperViewReadOnly : IMapperView {
    std::string canonical(std::string_view s) const override {
        auto id = Concrete::id_of(s);
        return Concrete::str(id);
    }
 
    std::vector<std::string> list_all() const override {
        std::vector<std::string> out;
        for (auto& id : Concrete::list_all()) {
            out.push_back(Concrete::str(id));
        }
        return out;
    }
 
    bool register_custom(std::string, std::vector<std::string>) override {
        return false;
    }
};
 
inline IMapperView& mapper_view(MapperKind k) {
    static MapperViewReadOnly<ObservableMapper>      obs;
    static MapperViewReadOnly<WCoefMapper>           wcoef;
    static MapperViewSimple<GroupMapper>             group;
    static MapperViewSimple<ParameterTypeMapper>     ptype;
    static MapperViewSimple<ModelMapper>             model;
    static MapperViewSimple<WilsonBasisMapper>       basis;
    static MapperViewSimple<ContributionTypeMapper>  contri;
    static MapperViewSimple<MassTypeMapper>          mass;
    static MapperViewSimple<ScaleTypeMapper>         scale;
    static MapperViewSimple<UncertaintyTypeMapper>   unc;
    static MapperViewReadOnly<DecayMapper>           decay;
    static MapperViewSimple<OrderMapper>             qcd;
 
    switch (k) {
        case MapperKind::Observable:      return obs;
        case MapperKind::WCoef:           return wcoef;
        case MapperKind::Group:           return group;
        case MapperKind::ParameterType:   return ptype;
        case MapperKind::Model:           return model;
        case MapperKind::WilsonBasis:     return basis;
        case MapperKind::ContributionType:return contri;
        case MapperKind::MassType:        return mass;
        case MapperKind::ScaleType:       return scale;
        case MapperKind::UncertaintyType: return unc;
        case MapperKind::Decay:           return decay;
        case MapperKind::QCDOrder:        return qcd;
    }
 
    return obs;
}
 
inline std::string canonical_of(MapperKind k, std::string_view s) {
    return mapper_view(k).canonical(s);
}
 
inline std::vector<std::string> list_all(MapperKind k) {
    return mapper_view(k).list_all();
}
 
inline bool register_custom(MapperKind k,
                            std::string canonical,
                            std::vector<std::string> aliases)
{
    return mapper_view(k).register_custom(std::move(canonical), std::move(aliases));
}
 
inline bool register_custom_wcoef(std::string canonical,
                                  std::vector<std::string> aliases,
                                  std::pair<int,int> flha)
{
    return WCoefMapper::register_custom(
        std::move(canonical),
        std::move(aliases),
        flha
    );
}
 
inline bool register_custom_observable(std::string canonical,
                                       std::vector<std::string> aliases,
                                       std::optional<LhaID> ext,
                                       std::string_view parent_decay)
{
    return ObservableMapper::register_custom(
        canonical,
        std::move(aliases),
        std::move(ext),
        parent_decay
    );
}
 
inline bool register_custom_decay_with_observables(
    std::string canonical,
    std::vector<std::string> aliases,
    std::vector<CustomObservableSpec> observables)
{
    return DecayMapper::register_custom_with_observables(
        std::move(canonical),
        std::move(aliases),
        std::move(observables)
    );
}
 
#endif // MAPPER_HUB_H