FunctionRegistry.h

Go to the documentation of this file.

// Copyright Contributors to the OpenVDB Project
// SPDX-License-Identifier: MPL-2.0


#ifndef OPENVDB_AX_CODEGEN_FUNCTION_REGISTRY_HAS_BEEN_INCLUDED
#define OPENVDB_AX_CODEGEN_FUNCTION_REGISTRY_HAS_BEEN_INCLUDED

#include "FunctionTypes.h"
#include "Types.h"

#include "../compiler/CompilerOptions.h"

#include <openvdb/version.h>

#include <unordered_map>

namespace openvdb {
OPENVDB_USE_VERSION_NAMESPACE
namespace OPENVDB_VERSION_NAME {

namespace ax {
namespace codegen {

class FunctionRegistry
{
public:
    using ConstructorT = FunctionGroup::UniquePtr(*)(const FunctionOptions&);
    using Ptr = std::shared_ptr<FunctionRegistry>;
    using UniquePtr = std::unique_ptr<FunctionRegistry>;

    struct RegisteredFunction
    {
        RegisteredFunction(const ConstructorT& creator, const bool internal = false)
            : mConstructor(creator), mFunction(), mInternal(internal) {}

        inline void create(const FunctionOptions& op) { mFunction = mConstructor(op); }

        inline const FunctionGroup* function() const { return mFunction.get(); }

        inline bool isInternal() const { return mInternal; }

    private:
        const ConstructorT mConstructor;
        FunctionGroup::Ptr mFunction;
        const bool mInternal;
    };

    using RegistryMap = std::unordered_map<std::string, RegisteredFunction>;

    void insert(const std::string& identifier,
        const ConstructorT creator,
        const bool internal = false);

    void insertAndCreate(const std::string& identifier,
                    const ConstructorT creator,
                    const FunctionOptions& op,
                    const bool internal = false);

    const FunctionGroup* getOrInsert(const std::string& identifier,
                      const FunctionOptions& op,
                      const bool allowInternalAccess);

    const FunctionGroup* get(const std::string& identifier,
                          const bool allowInternalAccess) const;

    void createAll(const FunctionOptions& op, const bool verify = false);

    inline const RegistryMap& map() const { return mMap; }

    inline bool empty() const { return mMap.empty(); }

    inline void clear() { mMap.clear(); }

private:
    RegistryMap mMap;
};

} // namespace codegen
} // namespace ax
} // namespace OPENVDB_VERSION_NAME
} // namespace openvdb

#endif // OPENVDB_AX_CODEGEN_FUNCTION_REGISTRY_HAS_BEEN_INCLUDED