Class: Puppet::Pops::Types::PHashType

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

Constant Summary collapse

DEFAULT = 
PHashType.new(nil, nil)
KEY_PAIR_TUPLE_SIZE = 
PIntegerType.new(2,2)
DEFAULT_KEY_PAIR_TUPLE = 
PTupleType.new([PUnitType::DEFAULT, PUnitType::DEFAULT], KEY_PAIR_TUPLE_SIZE)
DATA = 
PHashType.new(PScalarType::DEFAULT, PDataType::DEFAULT, DEFAULT_SIZE)
EMPTY = 
PHashType.new(PUnitType::DEFAULT, PUnitType::DEFAULT, PIntegerType.new(0, 0))

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?, #size_range

Methods inherited from PAnyType

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

Methods inherited from TypedModelObject

_ptype, create_ptype, register_ptypes

Methods included from PuppetObject

#_ptype

Constructor Details

#initialize(key_type, value_type, size_type = nil) ⇒ PHashType

Returns a new instance of PHashType.



2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
 
# File 'lib/puppet/pops/types/types.rb', line 2496

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

Instance Attribute Details

#key_type ⇒ Object 



2494
2495
2496
 
# File 'lib/puppet/pops/types/types.rb', line 2494

def key_type
  @key_type
end

#value_type ⇒ Object 



2494
2495
2496
 
# File 'lib/puppet/pops/types/types.rb', line 2494

def value_type
  @value_type
end

Class Method Details

.new_function(_, loader) ⇒ Object

Returns a new function that produces a Hash



2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
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
 
# File 'lib/puppet/pops/types/types.rb', line 2592

def self.new_function(_, loader)
  @new_function ||= Puppet::Functions.create_loaded_function(:new_hash, loader) do
    local_types do
      type 'KeyValueArray = Array[Tuple[Any,Any],1]'
    end

    dispatch :from_tuples do
      param           'KeyValueArray',  :from
    end

    dispatch :from_array do
      param           'Any',  :from
    end

    def from_tuples(tuple_array)
      Hash[tuple_array]
    end

    def from_array(from)
      case from
      when NilClass
        throw :undefined_value
      when Array
        if from.size == 0
          {}
        else
          unless from.size % 2 == 0
            raise TypeConversionError.new("odd number of arguments for Hash")
          end
          Hash[*from]
        end
      when Hash
        from
      else
        if PIterableType::DEFAULT.instance?(from)
          Hash[*Iterable.on(from).to_a]
        else
          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Hash")
        end
      end
    end
  end
end

.register_ptype(loader, ir) ⇒ Object 



2481
2482
2483
2484
2485
2486
2487
2488
2489
2490
2491
2492
 
# File 'lib/puppet/pops/types/types.rb', line 2481

def self.register_ptype(loader, ir)
  create_ptype(loader, ir, 'CollectionType',
    'key_type' => {
      KEY_TYPE => POptionalType.new(PType::DEFAULT),
      KEY_VALUE => nil
    },
    'value_type' => {
      KEY_TYPE => POptionalType.new(PType::DEFAULT),
      KEY_VALUE => nil,
    }
  )
end

Instance Method Details

#accept(visitor, guard) ⇒ Object 



2507
2508
2509
2510
2511
 
# File 'lib/puppet/pops/types/types.rb', line 2507

def accept(visitor, guard)
  super
  @key_type.accept(visitor, guard) unless @key_type.nil?
  @value_type.accept(visitor, guard) unless @value_type.nil?
end

#element_type ⇒ Object 



2513
2514
2515
2516
2517
2518
2519
 
# File 'lib/puppet/pops/types/types.rb', line 2513

def element_type
  if Puppet[:strict] != :off
    Puppet.warn_once(:deprecation, 'Puppet::Pops::Types::PHashType#element_type',
      'Puppet::Pops::Types::PHashType#element_type is deprecated, use #value_type instead')
  end
  @value_type
end

#eql?(o) ⇒ Boolean

Returns:

  • (Boolean) 


2574
2575
2576
 
# File 'lib/puppet/pops/types/types.rb', line 2574

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

#generalize ⇒ Object 



2521
2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
 
# File 'lib/puppet/pops/types/types.rb', line 2521

def generalize
  if self == DEFAULT || self == DATA || self == EMPTY
    self
  else
    key_t = @key_type
    key_t = key_t.generalize unless key_t.nil?
    value_t = @value_type
    value_t = value_t.generalize unless value_t.nil?
    @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
  end
end

#hash ⇒ Object 



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

def hash
  super ^ @key_type.hash ^ @value_type.hash
end

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

Returns:

  • (Boolean) 


2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
 
# File 'lib/puppet/pops/types/types.rb', line 2549

def instance?(o, guard = nil)
  return false unless o.is_a?(Hash)
  key_t = key_type
  value_t = value_type
  if (key_t.nil? || o.keys.all? {|key| key_t.instance?(key, guard) }) &&
      (value_t.nil? || o.values.all? {|value| value_t.instance?(value, guard) })
    size_t = size_type
    size_t.nil? || size_t.instance?(o.size, guard)
  else
    false
  end
end

#is_the_empty_hash? ⇒ Boolean

Returns:

  • (Boolean) 


2578
2579
2580
 
# File 'lib/puppet/pops/types/types.rb', line 2578

def is_the_empty_hash?
  self == EMPTY
end

#iterable?(guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


2562
2563
2564
 
# File 'lib/puppet/pops/types/types.rb', line 2562

def iterable?(guard = nil)
  true
end

#iterable_type(guard = nil) ⇒ Object 



2566
2567
2568
2569
2570
2571
2572
 
# File 'lib/puppet/pops/types/types.rb', line 2566

def iterable_type(guard = nil)
  if self == DEFAULT || self == EMPTY
    PIterableType.new(DEFAULT_KEY_PAIR_TUPLE)
  else
    PIterableType.new(PTupleType.new([@key_type, @value_type], KEY_PAIR_TUPLE_SIZE))
  end
end

#normalize(guard = nil) ⇒ Object 



2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
 
# File 'lib/puppet/pops/types/types.rb', line 2533

def normalize(guard = nil)
  if self == DEFAULT || self == DATA || self == EMPTY
    self
  else
    key_t = @key_type
    key_t = key_t.normalize(guard) unless key_t.nil?
    value_t = @value_type
    value_t = value_t.normalize(guard) unless value_t.nil?
    @size_type.nil? && @key_type.equal?(key_t) && @value_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, @size_type)
  end
end

#resolve(type_parser, loader) ⇒ Object 



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

def resolve(type_parser, loader)
  rkey_type = @key_type
  rkey_type = rkey_type.resolve(type_parser, loader) unless rkey_type.nil?
  rvalue_type = @value_type
  rvalue_type = rvalue_type.resolve(type_parser, loader) unless rvalue_type.nil?
  rkey_type.equal?(@key_type) && rvalue_type.equal?(@value_type) ? self : self.class.new(rkey_type, rvalue_type, @size_type)
end