operator-registry.h

// Copyright (c) 2020-now by the Zeek Project. See LICENSE for details.
 
#pragma once
 
#include <list>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include <hilti/ast/operator.h>
 
#define HILTI_OPERATOR(ns, cls)                                                                                        \
    Result<hilti::expression::ResolvedOperator*> instantiate(hilti::Builder* builder, Expressions operands, Meta meta) \
        const final {                                                                                                  \
        return {ns::operator_::cls::create(builder->context(), this, result(builder, operands, meta),                  \
                                           std::move(operands), meta)};                                                \
    }                                                                                                                  \
                                                                                                                       \
    std::string name() const final { return hilti::util::replace(#cls, "_::", "::"); }                                 \
    std::string _typename() const final { return hilti::util::typename_(*this); }
 
#define HILTI_OPERATOR_IMPLEMENTATION(cls)                                                                             \
    namespace {                                                                                                        \
    static hilti::operator_::Register<cls> _operator_##cls;                                                            \
    }
 
namespace hilti::operator_ {
 
class Registry {
public:
    const auto& byBuiltinFunctionID(const ID& id) { return _operators_by_builtin_function[id]; }
 
    const auto& byKind(Kind kind) { return _operators_by_kind[kind]; }
 
    const auto& byMethodID(const ID& id) { return _operators_by_method[id]; }
 
    const auto& byName(const std::string_view& name) { return _operators_by_name[std::string(name)]; }
 
    std::pair<bool, std::optional<std::vector<const Operator*>>> functionCallCandidates(
        const expression::UnresolvedOperator* op);
 
    const auto& operators() const { return _operators; }
 
    void register_(std::unique_ptr<Operator> op);
 
    void initPending(Builder* builder);
 
    bool havePending() const { return ! _pending.empty(); }
 
    void clear();
 
    void debugEnforceBuiltInsAreResolved(Builder* builder) const;
 
    static auto& singleton() {
        static Registry instance;
        return instance;
    }
 
private:
    std::list<std::unique_ptr<Operator>> _pending;             // all registered, but not yet initialized operators
    std::vector<std::unique_ptr<Operator>> _operators;         // all initialized operators
    std::map<std::string, const Operator*> _operators_by_name; // initialized operators by name
    std::map<Kind, std::vector<const Operator*>> _operators_by_kind; // initialized operators by kind
    std::map<ID, std::vector<const Operator*>>
        _operators_by_builtin_function; // initialized operators by builtin call operators; empty ID collect all without
                                        // a static name
    std::map<ID, std::vector<const Operator*>> _operators_by_method; // initialized operators by method
};
 
inline auto get(std::string_view name) {
    if ( const auto* op = Registry::singleton().byName(name) )
        return op;
    else
        logger().internalError(util::fmt("unknown operator '%s'", name));
}
 
template<typename T>
class Register {
public:
    Register() { Registry::singleton().register_(std::make_unique<T>()); }
};
 
inline auto& registry() { return Registry::singleton(); }
 
} // namespace hilti::operator_