Class: Puppet::Pops::Types::PTupleType

Inherits:
PAnyType show all
Includes:
Enumerable
Defined in:
lib/puppet/pops/types/types.rb

Constant Summary collapse

DEFAULT = 
PTupleType.new(EMPTY_ARRAY)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Enumerable

#uniq

Methods inherited from PAnyType

#==, #assignable?, #callable?, #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(types, size_type = nil) ⇒ PTupleType

Returns a new instance of PTupleType


2203
2204
2205
2206
 
# File 'lib/puppet/pops/types/types.rb', line 2203

def initialize(types, size_type = nil)
  @types = types
  @size_type = size_type.nil? ? nil : size_type.to_size
end

Instance Attribute Details

#size_type ⇒ Object (readonly)

If set, describes min and max required of the given types - if max > size of types, the last type entry repeats


2160
2161
2162
 
# File 'lib/puppet/pops/types/types.rb', line 2160

def size_type
  @size_type
end

#types ⇒ Object (readonly) 


2162
2163
2164
 
# File 'lib/puppet/pops/types/types.rb', line 2162

def types
  @types
end

Class Method Details

.register_ptype(loader, ir) ⇒ Object 


2147
2148
2149
2150
2151
2152
2153
2154
2155
 
# File 'lib/puppet/pops/types/types.rb', line 2147

def self.register_ptype(loader, ir)
  create_ptype(loader, ir, 'AnyType',
    'types' => PArrayType.new(PTypeType::DEFAULT),
    'size_type' => {
      KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
      KEY_VALUE => nil
    }
  )
end

Instance Method Details

#accept(visitor, guard) ⇒ Object 


2164
2165
2166
2167
2168
 
# File 'lib/puppet/pops/types/types.rb', line 2164

def accept(visitor, guard)
  super
  @size_type.accept(visitor, guard) unless @size_type.nil?
  @types.each { |elem| elem.accept(visitor, guard) }
end

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


2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
 
# File 'lib/puppet/pops/types/types.rb', line 2171

def callable_args?(callable_t, guard)
  unless size_type.nil?
    raise ArgumentError, 'Callable tuple may not have a size constraint when used as args'
  end

  params_tuple = callable_t.param_types
  param_block_t = callable_t.block_type
  arg_types = @types
  arg_block_t = arg_types.last
  if arg_block_t.kind_of_callable?(true, guard)
    # Can't pass a block to a callable that doesn't accept one
    return false if param_block_t.nil?

    # Check that the block is of the right tyṕe
    return false unless param_block_t.assignable?(arg_block_t, guard)

    # Check other arguments
    arg_count = arg_types.size - 1
    params_size_t = params_tuple.size_type || PIntegerType.new(*params_tuple.size_range)
    return false unless params_size_t.assignable?(PIntegerType.new(arg_count, arg_count), guard)

    ctypes = params_tuple.types
    arg_count.times do |index|
      return false unless (ctypes[index] || ctypes[-1]).assignable?(arg_types[index], guard)
    end
    return true
  end

  # Check that tuple is assignable and that the block (if declared) is optional
  params_tuple.assignable?(self, guard) && (param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT, guard))
end

#each ⇒ Object

Returns Enumerator for the types if no block is given, otherwise, calls the given block with each of the types in this tuple


2210
2211
2212
2213
2214
2215
2216
 
# File 'lib/puppet/pops/types/types.rb', line 2210

def each
  if block_given?
    types.each { |x| yield x }
  else
    types.to_enum
  end
end

#eql?(o) ⇒ Boolean 


2295
2296
2297
 
# File 'lib/puppet/pops/types/types.rb', line 2295

def eql?(o)
  self.class == o.class && @types == o.types && @size_type == o.size_type
end

#generalize ⇒ Object 


2218
2219
2220
2221
2222
2223
2224
 
# File 'lib/puppet/pops/types/types.rb', line 2218

def generalize
  if self == DEFAULT
    DEFAULT
  else
    alter_type_array(@types, :generalize) { |altered_types| PTupleType.new(altered_types, @size_type) }
  end
end

#hash ⇒ Object 


2291
2292
2293
 
# File 'lib/puppet/pops/types/types.rb', line 2291

def hash
  @size_type.hash ^ @types.hash
end

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


2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
 
# File 'lib/puppet/pops/types/types.rb', line 2244

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 Tuple type.
  return false unless o.instance_of?(Array)
  if @size_type
    return false unless @size_type.instance?(o.size, guard)
  else
    return false unless @types.empty? || @types.size == o.size
  end
  index = -1
  @types.empty? || o.all? do |element|
    @types.fetch(index += 1) { @types.last }.instance?(element, guard)
  end
end

#iterable?(guard = nil) ⇒ Boolean 


2258
2259
2260
 
# File 'lib/puppet/pops/types/types.rb', line 2258

def iterable?(guard = nil)
  true
end

#iterable_type(guard = nil) ⇒ Object 


2262
2263
2264
 
# File 'lib/puppet/pops/types/types.rb', line 2262

def iterable_type(guard = nil)
  PIterableType.new(PVariantType.maybe_create(types))
end

#new_function ⇒ Object 


2299
2300
2301
2302
2303
 
# File 'lib/puppet/pops/types/types.rb', line 2299

def new_function
  # Simply delegate to Array type and let the higher level assertion deal with
  # compliance with the Tuple type regarding the produced result.
  PArrayType.new_function(self)
end

#normalize(guard = nil) ⇒ Object 


2226
2227
2228
2229
2230
2231
2232
 
# File 'lib/puppet/pops/types/types.rb', line 2226

def normalize(guard = nil)
  if self == DEFAULT
    DEFAULT
  else
    alter_type_array(@types, :normalize, guard) { |altered_types| PTupleType.new(altered_types, @size_type) }
  end
end

#repeat_last_range ⇒ Object

Returns the number of accepted occurrences [min, max] of the last type in the tuple The defaults is [1,1]


2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
 
# File 'lib/puppet/pops/types/types.rb', line 2279

def repeat_last_range
  if @size_type.nil?
    return [1, 1]
  end
  types_size = @types.size
  from, to = @size_type.range
  min = from - (types_size-1)
  min = min <= 0 ? 0 : min
  max = to - (types_size-1)
  [min, max]
end

#resolve(loader) ⇒ Object 


2234
2235
2236
2237
2238
2239
2240
2241
2242
 
# File 'lib/puppet/pops/types/types.rb', line 2234

def resolve(loader)
  changed = false
  rtypes = @types.map do |type|
    rtype = type.resolve(loader)
    changed ||= !rtype.equal?(type)
    rtype
  end
  changed ? self.class.new(rtypes, @size_type) : self
end

#size_range ⇒ Object

Returns the number of elements accepted [min, max] in the tuple


2267
2268
2269
2270
2271
2272
2273
2274
 
# File 'lib/puppet/pops/types/types.rb', line 2267

def size_range
  if @size_type.nil?
    types_size = @types.size
    types_size == 0 ? [0, Float::INFINITY] : [types_size, types_size]
  else
    @size_type.range
  end
end