Class: Wongi::Engine::Network

Inherits:
Object
  • Object
show all
Includes:
CoreExt, Wongi::Engine::NetworkParts::Collectable
Defined in:
lib/wongi-engine/network.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Wongi::Engine::NetworkParts::Collectable

#add_collector, #add_error_collector, #collected_tokens, #collection, #collectors, #error_collectors, #errors

Methods included from CoreExt

included

Constructor Details

#initialize ⇒ Network

Returns a new instance of Network.



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/wongi-engine/network.rb', line 45

def initialize
  @overlays = [base_overlay]

  self.alpha_top = AlphaMemory.new(Template.new(:_, :_, :_), self)
  self.alpha_hash = { alpha_top.template => alpha_top }
  self.beta_top = RootNode.new(nil)
  beta_top.rete = self
  beta_top.seed
  self.queries = {}
  self.results = {}
  @revns = {}

  @productions = {}

  @collectors = {}
  @collectors[:error] = []
end

Instance Attribute Details

#alpha_top ⇒ Object

Returns the value of attribute alpha_top.



7
8
9
 
# File 'lib/wongi-engine/network.rb', line 7

def alpha_top
  @alpha_top
end

#beta_top ⇒ Object

Returns the value of attribute beta_top.



7
8
9
 
# File 'lib/wongi-engine/network.rb', line 7

def beta_top
  @beta_top
end

#productions ⇒ Object (readonly)

Returns the value of attribute productions.



8
9
10
 
# File 'lib/wongi-engine/network.rb', line 8

def productions
  @productions
end

#queries ⇒ Object

Returns the value of attribute queries.



7
8
9
 
# File 'lib/wongi-engine/network.rb', line 7

def queries
  @queries
end

#results ⇒ Object

Returns the value of attribute results.



7
8
9
 
# File 'lib/wongi-engine/network.rb', line 7

def results
  @results
end

Instance Method Details

#<<(something) ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/wongi-engine/network.rb', line 155

def <<(something)
  if something.respond_to?(:install)
    something.install(self)
  else
    case something
    when Array
      assert(WME.new(*something))
    when WME
      assert something
      # when Wongi::RDF::Statement
      #   assert WME.new( something.subject, something.predicate, something.object, self )
      # when Wongi::RDF::Document
      #  something.statements.each do |st|
      #    assert WME.new( st.subject, st.predicate, st.object, self )
      #  end
    when Network
      something.wmes.each { |wme| assert(wme) }
    else
      raise Error, "I don't know how to accept a #{something.class}"
    end
    self
  end
end

#alphas ⇒ Object 



75
76
77
 
# File 'lib/wongi-engine/network.rb', line 75

def alphas
  alpha_hash.values
end

#assert(wme) ⇒ Object 



116
117
118
 
# File 'lib/wongi-engine/network.rb', line 116

def assert(wme)
  default_overlay.assert(wme)
end

#base_overlay ⇒ Object Also known as: default_overlay

def import thing

case thing
when String, Numeric, TrueClass, FalseClass, NilClass, Wongi::RDF::Node
  thing
when Symbol
  thing
else
  thing
end

end



90
91
92
 
# File 'lib/wongi-engine/network.rb', line 90

def base_overlay
  @base_overlay ||= Overlay.new(self)
end

#cache(s, p, o) ⇒ Object 



209
210
211
 
# File 'lib/wongi-engine/network.rb', line 209

def cache(s, p, o)
  compile_alpha Template.new(s, p, o)
end

#compile_alpha(condition) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/wongi-engine/network.rb', line 191

def compile_alpha(condition)
  template = Template.new :_, :_, :_

  template.subject = condition.subject unless Template.variable?(condition.subject)
  template.predicate = condition.predicate unless Template.variable?(condition.predicate)
  template.object = condition.object unless Template.variable?(condition.object)

  # puts "COMPILED CONDITION #{condition} WITH KEY #{key}"
  return alpha_hash[template] if alpha_hash.key?(template)

  alpha = AlphaMemory.new(template, self)

  alpha_hash[template] = alpha
  initial_fill alpha

  alpha
end

#current_overlay ⇒ Object 



108
109
110
 
# File 'lib/wongi-engine/network.rb', line 108

def current_overlay
  overlays.last
end

#debug! ⇒ Object 



18
19
20
 
# File 'lib/wongi-engine/network.rb', line 18

def debug!
  extend NetworkParts::Debug
end

#dump ⇒ Object 



63
64
65
 
# File 'lib/wongi-engine/network.rb', line 63

def dump
  beta_top.dump
end

#each(*args, &block) ⇒ Object 



245
246
247
 
# File 'lib/wongi-engine/network.rb', line 245

def each(*args, &block)
  current_overlay.each(*args, &block)
end

#entity(subject) ⇒ Object 



112
113
114
 
# File 'lib/wongi-engine/network.rb', line 112

def entity(subject)
  current_overlay.entity(subject)
end

#execute(name, valuations) ⇒ Object

Raises:



230
231
232
233
234
235
 
# File 'lib/wongi-engine/network.rb', line 230

def execute(name, valuations)
  beta = queries[name]
  raise Error, "Undefined query #{name}; known queries are #{queries.keys}" unless beta

  beta.subst valuations
end

#exists?(wme) ⇒ Boolean

Returns:

  • (Boolean) 


241
242
243
 
# File 'lib/wongi-engine/network.rb', line 241

def exists?(wme)
  !find(wme.subject, wme.predicate, wme.object).nil?
end

#find(*args) ⇒ Object 



253
254
255
 
# File 'lib/wongi-engine/network.rb', line 253

def find(*args)
  each(*args).first
end

#initial_fill(alpha) ⇒ Object 



213
214
215
216
217
 
# File 'lib/wongi-engine/network.rb', line 213

def initial_fill(alpha)
  default_overlay.each(:_, :_, :_).to_a.each do |wme|
    alpha.activate wme if wme =~ alpha.template
  end
end

#inspect ⇒ Object 



237
238
239
 
# File 'lib/wongi-engine/network.rb', line 237

def inspect
  "<Rete>"
end

#install_query(query) ⇒ Object 



186
187
188
189
 
# File 'lib/wongi-engine/network.rb', line 186

def install_query(query)
  derived = query.import_into self
  prepare_query derived.name, derived.conditions, derived.parameters, derived.actions
end

#install_rule(rule) ⇒ Object 



179
180
181
182
183
184
 
# File 'lib/wongi-engine/network.rb', line 179

def install_rule(rule)
  derived = rule.import_into self
  production = build_production(rule.name, beta_top, derived.conditions, [], derived.actions, false)
  productions[rule.name] = production if rule.name
  production
end

#prepare_query(name, conditions, parameters, actions = []) ⇒ Object 



223
224
225
226
227
228
 
# File 'lib/wongi-engine/network.rb', line 223

def prepare_query(name, conditions, parameters, actions = [])
  query = queries[name] = RootNode.new(nil)
  query.rete = self
  query.seed(parameters.to_h { |param| [param, nil] })
  results[name] = build_production(name, query, conditions, parameters, actions, true)
end

#query(name, &block) ⇒ Object 



149
150
151
152
153
 
# File 'lib/wongi-engine/network.rb', line 149

def query(name, &block)
  q = DSL::Query.new name
  q.instance_eval(&block)
  self << q
end

#rdf! ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/wongi-engine/network.rb', line 22

def rdf!
  unless defined? Wongi::RDF::DocumentSupport
    begin
      require 'wongi-rdf'
    rescue LoadError
      raise "'wongi-rdf' is required for RDF support"
    end
  end

  extend Wongi::RDF::DocumentSupport

  class << self
    def statements
      alpha_top.wmes
    end
  end

  @namespaces = {}
  @blank_counter = 1
  @ns_counter = 0
  @used_blanks = {}
end

#real_assert(wme) ⇒ Object 



125
126
127
128
 
# File 'lib/wongi-engine/network.rb', line 125

def real_assert(wme)
  alphas_for(wme).each { |a| a.activate wme }
  wme
end

#real_retract(wme) ⇒ Object 



131
132
133
134
 
# File 'lib/wongi-engine/network.rb', line 131

def real_retract(wme)
  # p real_retract: {wme:}
  alphas_for(wme).each { |a| a.deactivate wme }
end

#remove_production(pnode) ⇒ Object 



219
220
221
 
# File 'lib/wongi-engine/network.rb', line 219

def remove_production(pnode)
  delete_node_with_ancestors pnode
end

#retract(wme, options = {}) ⇒ Object 



120
121
122
 
# File 'lib/wongi-engine/network.rb', line 120

def retract(wme, options = {})
  default_overlay.retract(wme, options)
end

#rule(name = nil, &block) ⇒ Object 



143
144
145
146
147
 
# File 'lib/wongi-engine/network.rb', line 143

def rule(name = nil, &block)
  r = DSL::Rule.new(name || generate_rule_name)
  r.instance_eval(&block)
  self << r
end

#select(*args, &block) ⇒ Object 



249
250
251
 
# File 'lib/wongi-engine/network.rb', line 249

def select(*args, &block)
  each(*args, &block)
end

#with_overlay(&block) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/wongi-engine/network.rb', line 67

def with_overlay(&block)
  child = current_overlay.new_child
  add_overlay(child)
  block.call(child)
ensure
  remove_overlay(child)
end

#wmes ⇒ Object Also known as: statements, facts 



136
137
138
 
# File 'lib/wongi-engine/network.rb', line 136

def wmes
  each.to_a
end