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

Inherits:

PCollectionType

• Object
• TypedModelObject
• PAnyType
• PCollectionType
• Puppet::Pops::Types::PHashType

Defined in:

lib/puppet/pops/types/types.rb

Constant Summary

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)

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

• #key_type ⇒ Object
• #value_type ⇒ Object

Attributes inherited from PCollectionType

#size_type

Class Method Summary

• .array_as_hash(value) ⇒ Object
• .new_function(type) ⇒ Object

  Returns a new function that produces a Hash.

• .register_ptype(loader, ir) ⇒ Object

Instance Method Summary

• #accept(visitor, guard) ⇒ Object
• #element_type ⇒ Object
• #eql?(o) ⇒ Boolean
• #generalize ⇒ Object
• #hash ⇒ Object
• #initialize(key_type, value_type, size_type = nil) ⇒ PHashType constructor

  A new instance of PHashType.

• #instance?(o, guard = nil) ⇒ Boolean
• #is_the_empty_hash? ⇒ Boolean
• #iterable?(guard = nil) ⇒ Boolean
• #iterable_type(guard = nil) ⇒ Object
• #normalize(guard = nil) ⇒ Object
• #resolve(loader) ⇒ Object

Methods inherited from PCollectionType

#has_empty_range?, #size_range

Methods inherited from PAnyType

#==, #assignable?, #callable?, #callable_args?, #callable_with?, #check_self_recursion, create, #create, #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(key_type, value_type, size_type = nil) ⇒ PHashType

Returns a new instance of PHashType

# File 'lib/puppet/pops/types/types.rb', line 2675

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.nil? ? PAnyType::DEFAULT : key_type
    @value_type = value_type.nil? ? PAnyType::DEFAULT : value_type
  end
end

Instance Attribute Details

#key_type ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2673

def key_type
  @key_type
end

#value_type ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2673

def value_type
  @value_type
end

Class Method Details

.array_as_hash(value) ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2764

def self.array_as_hash(value)
  return value unless value.is_a?(Array)
  result = {}
  value.each_with_index {|v, idx| result[idx] = array_as_hash(v) }
  result
end

.new_function(type) ⇒ Object

Returns a new function that produces a Hash

# File 'lib/puppet/pops/types/types.rb', line 2773

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

    dispatch :from_tree do
      param           'TreeArray',       :from
      optional_param  'NewHashOption',   :build_option
    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_tree(tuple_array, build_option = nil)
      if build_option.nil?
        return from_tuples(tuple_array)
      end
      # only remaining possible options is 'tree' or 'hash_tree'

      all_hashes = build_option == 'hash_tree'
      result = {}
      tuple_array.each do |entry|
        path = entry[0]
        value = entry[1]
        if path.empty?
          # root node (index [] was included - values merge into the result)
          # An array must be changed to a hash first as this is the root
          # (Cannot return an array from a Hash.new)
          if value.is_a?(Array)
            value.each_with_index {|v, idx| result[idx] = v }
          else
            result.merge!(value)
          end
        else
          r = path[0..-2].reduce(result) {|memo, idx| (memo.is_a?(Array) || memo.has_key?(idx)) ? memo[idx] : memo[idx] = {}}
          r[path[-1]]= (all_hashes ? PHashType.array_as_hash(value) : value)
        end
      end
      result
    end

    def from_array(from)
      case from
      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 = TypeCalculator.singleton.infer(from).generalize
          raise TypeConversionError.new(_("Value of type %{type} cannot be converted to Hash") % { type: t })
        end
      end
    end
  end
end

.register_ptype(loader, ir) ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2660

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

Instance Method Details

#accept(visitor, guard) ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2686

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

#element_type ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2692

def element_type
  if Puppet[:strict] != :off
    #TRANSLATOR 'Puppet::Pops::Types::PHashType#element_type' and '#value_type' are class and method names and should not be translated
    Puppet.warn_once('deprecations', '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

# File 'lib/puppet/pops/types/types.rb', line 2750

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

#generalize ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2701

def generalize
  if self == DEFAULT || self == EMPTY
    self
  else
    key_t = @key_type
    key_t = key_t.generalize
    value_t = @value_type
    value_t = value_t.generalize
    @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

# File 'lib/puppet/pops/types/types.rb', line 2723

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

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

# File 'lib/puppet/pops/types/types.rb', line 2727

def instance?(o, guard = nil)
  # The inferred type of a class derived from Hash is either Runtime or Object. It's not assignable to the Hash type.
  return false unless o.instance_of?(Hash)
  if o.keys.all? {|key| @key_type.instance?(key, guard) } && o.values.all? {|value| @value_type.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

# File 'lib/puppet/pops/types/types.rb', line 2754

def is_the_empty_hash?
  self == EMPTY
end

#iterable?(guard = nil) ⇒ Boolean

# File 'lib/puppet/pops/types/types.rb', line 2738

def iterable?(guard = nil)
  true
end

#iterable_type(guard = nil) ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2742

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

# File 'lib/puppet/pops/types/types.rb', line 2713

def normalize(guard = nil)
  if self == DEFAULT || self == EMPTY
    self
  else
    key_t = @key_type.normalize(guard)
    value_t = @value_type.normalize(guard)
    @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(loader) ⇒ Object

# File 'lib/puppet/pops/types/types.rb', line 2758

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