Class: Puppet::Pops::Types::PArrayType

Inherits:
PCollectionType show all
Defined in:
lib/puppet/pops/types/types.rb

Constant Summary collapse

DEFAULT = 
PArrayType.new(nil)
EMPTY = 
PArrayType.new(PUnitType::DEFAULT, ZERO_SIZE)

Constants inherited from PCollectionType

Puppet::Pops::Types::PCollectionType::DEFAULT_SIZE, Puppet::Pops::Types::PCollectionType::NOT_EMPTY_SIZE, Puppet::Pops::Types::PCollectionType::ZERO_SIZE

Instance Attribute Summary collapse

Attributes inherited from PCollectionType

#size_type

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from PCollectionType

#has_empty_range?, #iterable?, #size_range

Methods inherited from PAnyType

#==, #assignable?, #callable?, #callable_with?, #check_self_recursion, create, #create, #iterable?, #kind_of_callable?, #loader, #name, #new_function, #really_instance?, #roundtrip_with_string?, #simple_name, simple_name, #to_alias_expanded_s, #to_s

Methods inherited from TypedModelObject

_pcore_type, create_ptype, register_ptypes

Methods included from PuppetObject

#_pcore_all_contents, #_pcore_contents, #_pcore_init_hash, #_pcore_type, #to_s

Constructor Details

#initialize(element_type, size_type = nil) ⇒ PArrayType

Returns a new instance of PArrayType.



2537
2538
2539
2540
2541
2542
2543
2544
 
# File 'lib/puppet/pops/types/types.rb', line 2537

def initialize(element_type, size_type = nil)
  super(size_type)
  if !size_type.nil? && size_type.from == 0 && size_type.to == 0
    @element_type = PUnitType::DEFAULT
  else
    @element_type = element_type.nil? ? PAnyType::DEFAULT : element_type
  end
end

Instance Attribute Details

#element_type ⇒ Object (readonly) 



2535
2536
2537
 
# File 'lib/puppet/pops/types/types.rb', line 2535

def element_type
  @element_type
end

Class Method Details

.new_function(type) ⇒ Object

Returns a new function that produces an Array



2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
 
# File 'lib/puppet/pops/types/types.rb', line 2604

def self.new_function(type)
  @new_function ||= Puppet::Functions.create_loaded_function(:new_array, type.loader) do

    dispatch :to_array do
      param           'Variant[Array,Hash,Binary,Iterable]', :from
      optional_param  'Boolean[false]', :wrap
    end

    dispatch :wrapped do
      param  'Any',           :from
      param  'Boolean[true]', :wrap
    end

    argument_mismatch :on_error do
      param  'Any',             :from
      optional_param 'Boolean', :wrap
    end

    def wrapped(from, _)
      from.is_a?(Array) ? from : [from]
    end

    def to_array(from, _ = false)
      case from
      when Array
        from
      when Hash
        from.to_a
      when PBinaryType::Binary
        # For older rubies, the #bytes method returns an Enumerator that must be rolled out
        from.binary_buffer.bytes.to_a
      else
        Iterable.on(from).to_a
      end
    end

    def on_error(from, _ = false)
      t = TypeCalculator.singleton.infer(from).generalize
      _("Value of type %{type} cannot be converted to Array") % { type: t }
    end
  end
end

.register_ptype(loader, ir) ⇒ Object 



2526
2527
2528
2529
2530
2531
2532
2533
 
# File 'lib/puppet/pops/types/types.rb', line 2526

def self.register_ptype(loader, ir)
  create_ptype(loader, ir, 'CollectionType',
    'element_type' => {
      KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
      KEY_VALUE => PAnyType::DEFAULT
    }
  )
end

Instance Method Details

#accept(visitor, guard) ⇒ Object 



2546
2547
2548
2549
 
# File 'lib/puppet/pops/types/types.rb', line 2546

def accept(visitor, guard)
  super
  @element_type.accept(visitor, guard)
end

#callable_args?(callable, guard = nil) ⇒ 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.

Returns:

  • (Boolean) 


2552
2553
2554
2555
2556
2557
 
# File 'lib/puppet/pops/types/types.rb', line 2552

def callable_args?(callable, guard = nil)
  param_t = callable.param_types
  block_t = callable.block_type
  # does not support calling with a block, but have to check that callable is ok with missing block
  (param_t.nil? || param_t.assignable?(self, guard)) && (block_t.nil? || block_t.assignable?(PUndefType::DEFAULT, guard))
end

#eql?(o) ⇒ Boolean

Returns:

  • (Boolean) 


2568
2569
2570
 
# File 'lib/puppet/pops/types/types.rb', line 2568

def eql?(o)
  super && @element_type == o.element_type
end

#generalize ⇒ Object 



2559
2560
2561
2562
2563
2564
2565
2566
 
# File 'lib/puppet/pops/types/types.rb', line 2559

def generalize
  if PAnyType::DEFAULT.eql?(@element_type)
    DEFAULT
  else
    ge_type = @element_type.generalize
    @size_type.nil? && @element_type.equal?(ge_type) ? self : self.class.new(ge_type, nil)
  end
end

#hash ⇒ Object 



2572
2573
2574
 
# File 'lib/puppet/pops/types/types.rb', line 2572

def hash
  super ^ @element_type.hash
end

#instance?(o, guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


2590
2591
2592
2593
2594
2595
2596
 
# File 'lib/puppet/pops/types/types.rb', line 2590

def instance?(o, guard = nil)
  # The inferred type of a class derived from Array is either Runtime or Object. It's not assignable to the Array type.
  return false unless o.instance_of?(Array)
  return false unless o.all? {|element| @element_type.instance?(element, guard) }
  size_t = size_type
  size_t.nil? || size_t.instance?(o.size, guard)
end

#iterable_type(guard = nil) ⇒ Object 



2598
2599
2600
 
# File 'lib/puppet/pops/types/types.rb', line 2598

def iterable_type(guard = nil)
  PAnyType::DEFAULT.eql?(@element_type) ? PIterableType::DEFAULT : PIterableType.new(@element_type)
end

#normalize(guard = nil) ⇒ Object 



2576
2577
2578
2579
2580
2581
2582
2583
 
# File 'lib/puppet/pops/types/types.rb', line 2576

def normalize(guard = nil)
  if PAnyType::DEFAULT.eql?(@element_type)
    DEFAULT
  else
    ne_type = @element_type.normalize(guard)
    @element_type.equal?(ne_type) ? self : self.class.new(ne_type, @size_type)
  end
end

#resolve(loader) ⇒ Object 



2585
2586
2587
2588
 
# File 'lib/puppet/pops/types/types.rb', line 2585

def resolve(loader)
  relement_type = @element_type.resolve(loader)
  relement_type.equal?(@element_type) ? self : self.class.new(relement_type, @size_type)
end