Class: Pione::Lang::ParameterSet

Inherits:
Piece
  • Object
show all
Includes:
Enumerable
Defined in:
lib/pione/lang/parameters.rb

Overview

ParameterSet is a piece class for set of actual parameters.

Instance Method Summary collapse

Methods inherited from Piece

piece_type_name

Methods included from Util::Positionable

#line_and_column, #pos, #set_source_position

Instance Method Details

#==(other) ⇒ Object Also known as: eql? 



84
85
86
87
 
# File 'lib/pione/lang/parameters.rb', line 84

def ==(other)
  return false unless other.kind_of?(self.class)
  table == other.table
end

#delete_all(names) ⇒ Object

Return a parameter set excluding the names.



26
27
28
 
# File 'lib/pione/lang/parameters.rb', line 26

def delete_all(names)
  set(table: table.reject{|key, _| names.include?(key)})
end

#eval(env) ⇒ Object

Evaluate the object with variable table.



11
12
13
 
# File 'lib/pione/lang/parameters.rb', line 11

def eval(env)
  set(table: Hash[*table.map{|key, val| [key, val.eval(env)]}.flatten(1)])
end

#expand ⇒ Object

Expand parameter value sequences.



48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/pione/lang/parameters.rb', line 48

def expand
  if block_given?
    array = table.map do |k, v|
      [k, (v.respond_to?(:each) and v.distribution == :each) ? v.each : v]
    end
    find_atomic_composites(array, Hash.new) do |t|
      yield set(table: t.inject(Hash.new){|h, (k, v)| h.merge(k => v)})
    end
  else
    Enumerator.new(self, :expand)
  end
end

#filter(names) ⇒ Object

Return a parameter set that match the names.



21
22
23
 
# File 'lib/pione/lang/parameters.rb', line 21

def filter(names)
  set(table: table.select{|key, _| names.include?(key)})
end

#find_atomic_composites(array, table, &b) ⇒ Object

Find atomic parameters recursively.



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/pione/lang/parameters.rb', line 62

def find_atomic_composites(array, table, &b)
  # end recursion
  return b.call(table) if array.empty?

  # find atomic composites
  key, enum = array.first
  tail = array.drop(1)
  loop do
    if enum.kind_of?(Enumerator)
      find_atomic_composites(tail, table.merge(key => enum.next), &b)
    else
      find_atomic_composites(tail, table.merge(key => enum), &b)
      raise StopIteration
    end
  end
  enum.rewind if enum.kind_of?(Enumerator)
end

#merge(other) ⇒ Object

Merge values of the other parameter set.



16
17
18
 
# File 'lib/pione/lang/parameters.rb', line 16

def merge(other)
  set(table: table.merge(other.table))
end

#merge_default_values(rule_condition) ⇒ Object

Merge default values of the rule condition.



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/pione/lang/parameters.rb', line 31

def merge_default_values(rule_condition)
  tbl = Hash.new

  rule_condition.param_definition.each do |key, param_definition|
    unless keys.include?(key)
      tbl[key] = param_definition.value
    end
  end

  set(table: table.merge(tbl))
end

#textize ⇒ Object 



43
44
45
 
# File 'lib/pione/lang/parameters.rb', line 43

def textize
  "{" + table.keys.sort.map{|k| "%s:%s" % [k, table[k].textize]}.join(", ") + "}"
end

#to_json(*args) ⇒ Object 



80
81
82
 
# File 'lib/pione/lang/parameters.rb', line 80

def to_json(*args)
  table.to_json(*args)
end