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

Inherits:

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 collapse

#dispatchers ⇒ Object readonly private

Instance Method Summary collapse

#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.
#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.


10
11
12

# 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.


7
8
9

# 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.


49
50
51

# File 'lib/puppet/pops/functions/dispatcher.rb', line 49

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).

# File 'lib/puppet/pops/functions/dispatcher.rb', line 30

def dispatch(instance, calling_scope, args, &block)
  found = @dispatchers.find { |d| d.type.callable_with?(args, block) }
  unless found
    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 found.argument_mismatch_handler?
    msg = found.invoke(instance, calling_scope, args)
    raise ArgumentError, "'#{instance.class.name}' #{msg}"
  end

  catch(:next) do
    found.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


18
19
20

# File 'lib/puppet/pops/functions/dispatcher.rb', line 18

def empty?
  @dispatchers.empty?
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.


68
69
70

# File 'lib/puppet/pops/functions/dispatcher.rb', line 68

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 56

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