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::ZERO_SIZE

Instance Attribute Summary collapse

Attributes inherited from PCollectionType

#element_type, #size_type

Instance Method Summary collapse

Methods inherited from PCollectionType

#size_range

Methods inherited from PAnyType

#==, #assignable?, #callable?, #callable_args?, #kind_of_callable?, #simple_name, #to_alias_expanded_s, #to_s

Constructor Details

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

Returns a new instance of PHashType.



1685
1686
1687
1688
 
# File 'lib/puppet/pops/types/types.rb', line 1685

def initialize(key_type, value_type, size_type = nil)
  super(value_type, size_type)
  @key_type = key_type
end

Instance Attribute Details

#key_type ⇒ Object 



1683
1684
1685
 
# File 'lib/puppet/pops/types/types.rb', line 1683

def key_type
  @key_type
end

Instance Method Details

#accept(visitor, guard) ⇒ Object 



1690
1691
1692
1693
 
# File 'lib/puppet/pops/types/types.rb', line 1690

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

#eql?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1748
1749
1750
 
# File 'lib/puppet/pops/types/types.rb', line 1748

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

#generalize ⇒ Object 



1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
 
# File 'lib/puppet/pops/types/types.rb', line 1695

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 = @element_type
    value_t = value_t.generalize unless value_t.nil?
    @size_type.nil? && @key_type.equal?(key_t) && @element_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
  end
end

#hash ⇒ Object 



1719
1720
1721
 
# File 'lib/puppet/pops/types/types.rb', line 1719

def hash
  super ^ @key_type.hash
end

#instance?(o) ⇒ Boolean

Returns:

  • (Boolean) 


1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
 
# File 'lib/puppet/pops/types/types.rb', line 1723

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

#is_the_empty_hash? ⇒ Boolean

Returns:

  • (Boolean) 


1752
1753
1754
 
# File 'lib/puppet/pops/types/types.rb', line 1752

def is_the_empty_hash?
  self == EMPTY
end

#iterable?(guard = nil) ⇒ Boolean

Returns:

  • (Boolean) 


1736
1737
1738
 
# File 'lib/puppet/pops/types/types.rb', line 1736

def iterable?(guard = nil)
  true
end

#iterable_type(guard = nil) ⇒ Object 



1740
1741
1742
1743
1744
1745
1746
 
# File 'lib/puppet/pops/types/types.rb', line 1740

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

#normalize(guard = nil) ⇒ Object 



1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
 
# File 'lib/puppet/pops/types/types.rb', line 1707

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 = @element_type
    value_t = value_t.normalize(guard) unless value_t.nil?
    @size_type.nil? && @key_type.equal?(key_t) && @element_type.equal?(value_t) ? self : PHashType.new(key_t, value_t, nil)
  end
end