Class: Norikra::TypedefManager

Inherits:
Object
  • Object
show all
Defined in:
lib/norikra/typedef_manager.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ TypedefManager

Returns a new instance of TypedefManager.



10
11
12
13
 
# File 'lib/norikra/typedef_manager.rb', line 10

def initialize(opts={})
  @typedefs = {} # {target => Typedef}
  @mutex = Mutex.new
end

Instance Attribute Details

#typedefs ⇒ Object (readonly)

Returns the value of attribute typedefs.



8
9
10
 
# File 'lib/norikra/typedef_manager.rb', line 8

def typedefs
  @typedefs
end

Instance Method Details

#activate(target, fieldset) ⇒ Object 



40
41
42
43
 
# File 'lib/norikra/typedef_manager.rb', line 40

def activate(target, fieldset)
  fieldset.bind(target, :base)
  @typedefs[target].activate(fieldset)
end

#add_target(target, fields) ⇒ Object 



20
21
22
23
24
25
26
27
 
# File 'lib/norikra/typedef_manager.rb', line 20

def add_target(target, fields)
  # fields nil || [] => lazy
  # fields {'fieldname' => 'type'}
  @mutex.synchronize do
    raise Norikra::ArgumentError, "target '#{target}' already exists" if @typedefs[target]
    @typedefs[target] = Typedef.new(fields)
  end
end

#base_fieldset(target) ⇒ Object 



126
127
128
 
# File 'lib/norikra/typedef_manager.rb', line 126

def base_fieldset(target)
  @typedefs[target].baseset
end

#bind_fieldset(target, level, fieldset) ⇒ Object 



93
94
95
96
 
# File 'lib/norikra/typedef_manager.rb', line 93

def bind_fieldset(target, level, fieldset)
  fieldset.bind(target, level)
  @typedefs[target].push(level, fieldset)
end

#dump_target(name) ⇒ Object 



155
156
157
 
# File 'lib/norikra/typedef_manager.rb', line 155

def dump_target(name)
  @typedefs[name].dump_all
end

#field_list(target) ⇒ Object 



15
16
17
18
 
# File 'lib/norikra/typedef_manager.rb', line 15

def field_list(target)
  @typedefs[target].dump.map{|key,hash_value| hash_value}
  # @typedefs[target].fields.values.sort{|a,b| a.name <=> b.name}.map(&:to_hash)
end

#generate_base_fieldset(target, event) ⇒ Object 



106
107
108
109
110
 
# File 'lib/norikra/typedef_manager.rb', line 106

def generate_base_fieldset(target, event)
  guessed = @typedefs[target].simple_guess(event, strict: false, baseset: true) # all fields are non-optional
  guessed.update(@typedefs[target].fields, false)
  guessed
end

#generate_fieldset_mapping(query) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/norikra/typedef_manager.rb', line 69

def generate_fieldset_mapping(query)
  fields_set = {}
  nullables_set = {}

  query.targets.each do |target|
    fields_set[target] = query.fields(target)
    nullables_set[target] = query.nullable_fields(target)
  end
  query.fields(nil).each do |field|
    assumed = query.targets.select{|t| @typedefs[t].field_defined?([field])}
    if assumed.size != 1
      raise Norikra::ClientError, "cannot determine target for field '#{field}' in this query"
    end
    fields_set[assumed.first].push(field)
    nullables_set[assumed.first].push(field) if query.nullable_fields(nil).include?(field)
  end

  mapping = {}
  fields_set.each do |target,fields|
    mapping[target] = generate_query_fieldset(target, fields.sort.uniq, nullables_set[target].sort.uniq, query.name, query.group)
  end
  mapping
end

#generate_query_fieldset(target, field_name_list, nullable_list, query_name, query_group) ⇒ Object 



112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/norikra/typedef_manager.rb', line 112

def generate_query_fieldset(target, field_name_list, nullable_list, query_name, query_group)
  # all fields of field_name_list should exists in definitions of typedef fields
  # for this premise, call 'bind_fieldset' for data fieldset before this method.
  required_fields = {}
  @mutex.synchronize do
    @typedefs[target].fields.each do |fieldname, field|
      if field_name_list.include?(fieldname) || !(field.optional?)
        required_fields[fieldname] = {type: field.type, optional: field.optional, nullable: nullable_list.include?(fieldname)}
      end
    end
  end
  Norikra::FieldSet.new(required_fields, nil, 0, [query_name, (query_group || '')])
end

#lazy?(target) ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/norikra/typedef_manager.rb', line 36

def lazy?(target)
  @typedefs[target].lazy?
end

#ready?(query) ⇒ Boolean

Returns:

  • (Boolean) 


49
50
51
52
 
# File 'lib/norikra/typedef_manager.rb', line 49

def ready?(query)
  query.targets.all?{|t| @typedefs[t] && ! @typedefs[t].lazy? && @typedefs[t].field_defined?(query.fields(t))} &&
    query.fields(nil).all?{|f| query.targets.any?{|t| @typedefs[t].field_defined?([f])}}
end

#refer(target_name, event, strict = false) ⇒ Object 



151
152
153
 
# File 'lib/norikra/typedef_manager.rb', line 151

def refer(target_name, event, strict=false)
  @typedefs[target_name].refer(event, strict)
end

#register_waiting_fields(query) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/norikra/typedef_manager.rb', line 54

def register_waiting_fields(query)
  query.targets.each do |t|
    next if t.nil?

    typedef = @typedefs[t]
    fields = typedef.fields

    query.fields(t).each do |fieldname|
      if !fields.has_key?(fieldname) && !typedef.waiting_fields.include?(fieldname)
        typedef.waiting_fields.push(fieldname)
      end
    end
  end
end

#remove_target(target) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/norikra/typedef_manager.rb', line 29

def remove_target(target)
  @mutex.synchronize do
    raise Norikra::ArgumentError, "target '#{target}' doesn't exists" unless @typedefs[target]
    @typedefs.delete(target)
  end
end

#replace_fieldset(target, old_fieldset, new_fieldset) ⇒ Object 



102
103
104
 
# File 'lib/norikra/typedef_manager.rb', line 102

def replace_fieldset(target, old_fieldset, new_fieldset)
  @typedefs[target].replace(:data, old_fieldset, new_fieldset)
end

#reserve(target, field, type) ⇒ Object 



45
46
47
 
# File 'lib/norikra/typedef_manager.rb', line 45

def reserve(target, field, type)
  @typedefs[target].reserve(field, type)
end

#subsets(target, fieldset) ⇒ Object

manager.subsets(target, data_fieldset) #=> [query_fieldset]



130
131
132
133
134
135
136
137
138
139
 
# File 'lib/norikra/typedef_manager.rb', line 130

def subsets(target, fieldset) # manager.subsets(target, data_fieldset) #=> [query_fieldset]
  sets = []
  @mutex.synchronize do
    @typedefs[target].queryfieldsets.each do |set|
      sets.push(set) if set.subset?(fieldset)
    end
    sets.push(@typedefs[target].baseset)
  end
  sets
end

#supersets(target, fieldset) ⇒ Object

manager.supersets(target, query_fieldset) #=> [data_fieldset]



141
142
143
144
145
146
147
148
149
 
# File 'lib/norikra/typedef_manager.rb', line 141

def supersets(target, fieldset) # manager.supersets(target, query_fieldset) #=> [data_fieldset]
  sets = []
  @mutex.synchronize do
    @typedefs[target].datafieldsets.each do |set|
      sets.push(set) if fieldset.subset?(set)
    end
  end
  sets
end

#unbind_fieldset(target, level, fieldset) ⇒ Object 



98
99
100
 
# File 'lib/norikra/typedef_manager.rb', line 98

def unbind_fieldset(target, level, fieldset)
  @typedefs[target].pop(level, fieldset)
end