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



2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
 
# File 'lib/puppet/pops/types/types.rb', line 2432

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 



2430
2431
2432
 
# File 'lib/puppet/pops/types/types.rb', line 2430

def key_type
  @key_type
end

#value_type ⇒ Object 



2430
2431
2432
 
# File 'lib/puppet/pops/types/types.rb', line 2430

def value_type
  @value_type
end

Class Method Details

.new_function(_, loader) ⇒ Object

Returns a new function that produces a Hash



2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
 
# File 'lib/puppet/pops/types/types.rb', line 2528

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 



2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
 
# File 'lib/puppet/pops/types/types.rb', line 2417

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 



2443
2444
2445
2446
2447
 
# File 'lib/puppet/pops/types/types.rb', line 2443

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 



2449
2450
2451
2452
2453
2454
2455
 
# File 'lib/puppet/pops/types/types.rb', line 2449

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) 


2510
2511
2512
 
# File 'lib/puppet/pops/types/types.rb', line 2510

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

#generalize ⇒ Object 



2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
 
# File 'lib/puppet/pops/types/types.rb', line 2457

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 



2481
2482
2483
 
# File 'lib/puppet/pops/types/types.rb', line 2481

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

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

Returns:

  • (Boolean) 


2485
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
 
# File 'lib/puppet/pops/types/types.rb', line 2485

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) 


2514
2515
2516
 
# File 'lib/puppet/pops/types/types.rb', line 2514

def is_the_empty_hash?
  self == EMPTY
end

#iterable?(guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


2498
2499
2500
 
# File 'lib/puppet/pops/types/types.rb', line 2498

def iterable?(guard = nil)
  true
end

#iterable_type(guard = nil) ⇒ Object 



2502
2503
2504
2505
2506
2507
2508
 
# File 'lib/puppet/pops/types/types.rb', line 2502

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 



2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
 
# File 'lib/puppet/pops/types/types.rb', line 2469

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, nil)
  end
end

#resolve(type_parser, loader) ⇒ Object 



2518
2519
2520
2521
2522
2523
2524
 
# File 'lib/puppet/pops/types/types.rb', line 2518

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