Struct FunctionOverloads

pub struct FunctionOverloads<T>(/* private fields */);

Collection of function overloads grouped by argument kinds.

FunctionOverloads<T> manages multiple function overloads that share the same name but have different argument signatures. This allows CEL to support function overloading based on argument types, similar to many programming languages.

Type Parameters

• T: The type of function stored (implementation, declaration, or either)

Examples

use cel_cxx::function::{FunctionOverloads, FunctionDeclOrImpl};

let mut overloads = FunctionOverloads::<FunctionDeclOrImpl>::new();
// Add different overloads for the same function name

Implementations

impl<T: FunctionTypeOverload> FunctionOverloads<T>

pub fn new() -> Self

Creates a new empty function overload collection.

pub fn find( &self, member: bool, kinds: &[Kind], ) -> Option<&FunctionKindOverload<T>>

Finds a function overload by member type and argument kinds.

Parameters

• member: Whether to find member functions (true) or global functions (false)
• kinds: Argument kinds to match

Returns

Returns Some(&FunctionKindOverload) if found, None otherwise

pub fn find_mut( &mut self, member: bool, kinds: &[Kind], ) -> Option<&mut FunctionKindOverload<T>>

where T: Send + Sync,

Finds a mutable reference to a function overload by member flag and argument kinds.

Parameters

• member: Whether to search for member functions
• kinds: Argument kinds to match

Returns

Mutable reference to the matching overload, or None if not found

pub fn entries(&self) -> impl Iterator<Item = &FunctionKindOverload<T>>

Returns an iterator over all function overloads.

Examples

use cel_cxx::function::{FunctionOverloads, FunctionDeclOrImpl};

let overloads = FunctionOverloads::<FunctionDeclOrImpl<'_>>::new();
for overload in overloads.entries() {
    // Process each overload
}

pub fn entries_mut( &mut self, ) -> impl Iterator<Item = &mut FunctionKindOverload<T>>

Returns a mutable iterator over all function overloads.

pub fn clear(&mut self)

Clears all function overloads.

pub fn remove<I, K>(&mut self, member: bool, args: I) -> Result<(), Error>

where I: IntoIterator<Item = K>, K: Into<Kind>,

Removes a function overload by member flag and argument kinds.

Parameters

• member: Whether to remove member functions
• args: Argument kinds to match for removal

Returns

Ok(()) if removal was successful, Err(Error) if not found

impl<'f> FunctionOverloads<FunctionDeclOrImpl<'f>>

pub fn add_impl( &mut self, member: bool, f: Function<'f>, ) -> Result<&mut Self, Error>

Adds a function implementation to the overloads.

This method adds a concrete function implementation to the appropriate overload group based on its signature. If no matching overload exists, a new one is created.

Arguments

• member - Whether this is a member function
• f - The function implementation to add

Returns

Ok(&mut Self) for method chaining, or Err(Error) if addition fails

Errors

Returns error if the function signature conflicts with existing registrations.

pub fn add_decl( &mut self, member: bool, f: FunctionType, ) -> Result<&mut Self, Error>

Adds a function declaration to the overloads.

This method adds a function type signature (declaration) to the appropriate overload group. Declarations provide type information for compile-time checking without requiring an implementation.

Arguments

• member - Whether this is a member function declaration
• f - The function type signature to add

Returns

Ok(&mut Self) for method chaining, or Err(Error) if addition fails

Errors

Returns error if the function signature conflicts with existing registrations.

impl<'f> FunctionOverloads<Function<'f>>

pub fn add(&mut self, member: bool, f: Function<'f>) -> Result<&mut Self, Error>

Adds a function to the overloads.

This method adds a function to the appropriate overload group based on its signature. This is used when working with pure function implementations without separate declarations.

Arguments

• member - Whether this is a member function
• f - The function to add

Returns

Ok(&mut Self) for method chaining, or Err(Error) if addition fails

Errors

Returns error if the function signature conflicts with existing registrations.

Trait Implementations

impl<T: Clone> Clone for FunctionOverloads<T>

fn clone(&self) -> FunctionOverloads<T>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for FunctionOverloads<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for FunctionOverloads<T>

fn default() -> FunctionOverloads<T>

Returns the “default value” for a type.