Class: Puppet::Pops::Functions::Dispatcher Private

Inherits:

Object

• Object
• Puppet::Pops::Functions::Dispatcher

Defined in:

lib/puppet/pops/functions/dispatcher.rb

Overview

This class is part of a private API. You should avoid using this class if possible, as it may be removed or be changed in the future.

Evaluate the dispatches defined as Dispatch instances to call the appropriate method on the Function instance.

Instance Attribute Summary

• #dispatchers ⇒ Object readonly private

Instance Method Summary

• #add(a_dispatch) ⇒ Object private

  Adds a dispatch directly to the set of dispatchers.

• #dispatch(instance, calling_scope, args, &block) ⇒ Object private

  Dispatches the call to the first found signature (entry with matching type).

• #empty? ⇒ Boolean private

  Answers if dispatching has been defined.

• #find_matching_dispatcher(args, &block) ⇒ Object private
• #initialize ⇒ Dispatcher constructor private

  A new instance of Dispatcher.

• #signatures ⇒ Object private
• #to_type ⇒ Object private

  Produces a CallableType for a single signature, and a

  Constructor Details

  #initialize ⇒ Dispatcher

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  Returns a new instance of Dispatcher.

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 10
  
  def initialize()
    @dispatchers = [ ]
  end

  Instance Attribute Details

  #dispatchers ⇒ Object (readonly)

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 7
  
  def dispatchers
    @dispatchers
  end

  Instance Method Details

  #add(a_dispatch) ⇒ Object

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  Adds a dispatch directly to the set of dispatchers.

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 53
  
  def add(a_dispatch)
    @dispatchers << a_dispatch
  end

  #dispatch(instance, calling_scope, args, &block) ⇒ Object

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  Dispatches the call to the first found signature (entry with matching type).

  Parameters:

  • instance (Puppet::Functions::Function) —

    • the function to call

  • calling_scope (T.B.D::Scope) —

    • the scope of the caller

  • args (Array<Object>) —

    • the given arguments in the form of an Array

  Returns:

  • (Object) —

    • what the called function produced

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 34
  
  def dispatch(instance, calling_scope, args, &block)
  
    dispatcher = find_matching_dispatcher(args, &block)
    unless dispatcher
      args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(block_given? ? args + [block] : args)
      raise ArgumentError, Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(instance.class.name, signatures, args_type)
    end
    if dispatcher.argument_mismatch_handler?
      msg = dispatcher.invoke(instance, calling_scope, args)
      raise ArgumentError, "'#{instance.class.name}' #{msg}"
    end
  
    catch(:next) do
      dispatcher.invoke(instance, calling_scope, args, &block)
    end
  end

  #empty? ⇒ Boolean

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  Answers if dispatching has been defined

  Returns:

  • (Boolean) —

    true if dispatching has been defined

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 18
  
  def empty?
    @dispatchers.empty?
  end

  #find_matching_dispatcher(args, &block) ⇒ Object

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 22
  
  def find_matching_dispatcher(args, &block)
    @dispatchers.find { |d| d.type.callable_with?(args, block) }
  end

  #signatures ⇒ Object

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 72
  
  def signatures
    @dispatchers.reject { |dispatcher| dispatcher.argument_mismatch_handler? }
  end

  #to_type ⇒ Object

  This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

  Produces a CallableType for a single signature, and a

  # File 'lib/puppet/pops/functions/dispatcher.rb', line 60
  
  def to_type()
    # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
    # should be treated as immutable).
    #
    callables = dispatchers.map { | dispatch | dispatch.type }
  
    # multiple signatures, produce a Variant type of Callable1-n (must copy them)
    # single signature, produce single Callable
    callables.size > 1 ?  Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
  end

  Generated on Sun Jan 29 12:41:28 2023 by yard 0.9.28 (ruby-3.0.2).