public:

// Represents a single overload for a lazily provided function.

using LazyOverload = cel::FunctionRegistry::LazyOverload;

CelFunctionRegistry() = default;

~CelFunctionRegistry() = default;

using Registrar = absl::Status (*)(CelFunctionRegistry*,

const InterpreterOptions&);

// Register CelFunction object. Object ownership is

// passed to registry.

// Function registration should be performed prior to

// CelExpression creation.

absl::Status Register(std::unique_ptr<CelFunction> function) {

// We need to copy the descriptor, otherwise there is no guarantee that the

// lvalue reference to the descriptor is valid as function may be destroyed.

auto descriptor = function->descriptor();

return Register(descriptor, std::move(function));

}

absl::Status Register(const cel::FunctionDescriptor& descriptor,

std::unique_ptr<cel::Function> implementation) {

return modern_registry_.Register(descriptor, std::move(implementation));

}

absl::Status RegisterAll(std::initializer_list<Registrar> registrars,

const InterpreterOptions& opts);

// Register a lazily provided function. This overload uses a default provider

// that delegates to the activation at evaluation time.

absl::Status RegisterLazyFunction(const CelFunctionDescriptor& descriptor) {

return modern_registry_.RegisterLazyFunction(descriptor);

}

// Find a subset of CelFunction that match overload conditions

// As types may not be available during expression compilation,

// further narrowing of this subset will happen at evaluation stage.

// name - the name of CelFunction;

// receiver_style - indicates whether function has receiver style;

// types - argument types. If type is not known during compilation,

// DYN value should be passed.

//

// Results refer to underlying registry entries by pointer. Results are

// invalid after the registry is deleted.

std::vector<const CelFunction*> FindOverloads(

absl::string_view name, bool receiver_style,

const std::vector<CelValue::Type>& types) const;

std::vector<cel::FunctionOverloadReference> FindStaticOverloads(

absl::string_view name, bool receiver_style,

const std::vector<cel::Kind>& types) const {

return modern_registry_.FindStaticOverloads(name, receiver_style, types);

}

// Find subset of CelFunction providers that match overload conditions

// As types may not be available during expression compilation,

// further narrowing of this subset will happen at evaluation stage.

// name - the name of CelFunction;

// receiver_style - indicates whether function has receiver style;

// types - argument types. If type is not known during compilation,

// DYN value should be passed.

std::vector<const CelFunctionDescriptor*> FindLazyOverloads(

absl::string_view name, bool receiver_style,

const std::vector<CelValue::Type>& types) const;

// Find subset of CelFunction providers that match overload conditions

// As types may not be available during expression compilation,

// further narrowing of this subset will happen at evaluation stage.

// name - the name of CelFunction;

// receiver_style - indicates whether function has receiver style;

// types - argument types. If type is not known during compilation,

// DYN value should be passed.

std::vector<LazyOverload> ModernFindLazyOverloads(

absl::string_view name, bool receiver_style,

const std::vector<CelValue::Type>& types) const {

return modern_registry_.FindLazyOverloads(name, receiver_style, types);

}

// Retrieve list of registered function descriptors. This includes both

// static and lazy functions.

absl::node_hash_map<std::string, std::vector<const cel::FunctionDescriptor*>>

ListFunctions() const {

return modern_registry_.ListFunctions();

}

// cel internal accessor for returning backing modern registry.

//

// This is intended to allow migrating the CEL evaluator internals while

// maintaining the existing CelRegistry API.

//

// CEL users should not use this.

const cel::FunctionRegistry& InternalGetRegistry() const {

return modern_registry_;

}

cel::FunctionRegistry& InternalGetRegistry() { return modern_registry_; }

private:

cel::FunctionRegistry modern_registry_;

// Maintain backwards compatibility for callers expecting CelFunction

// interface.

// This is not used internally, but some client tests check that a specific

// CelFunction overload is used.

// Lazily initialized.

mutable absl::Mutex mu_;

mutable absl::flat_hash_map<const cel::Function*,

std::unique_ptr<CelFunction>>

functions_ ABSL_GUARDED_BY(mu_);