Class: Pione::Lang::Eliminator

Inherits:
Object
  • Object
show all
Defined in:
lib/pione/lang/feature-expr.rb

Overview

feature operations

Constant Summary collapse

OPERATIONS = 
[
  :eliminate_requisite_feature,
  :eliminate_requisite_feature_by_almighty_feature,
  :eliminate_blocking_feature,
  :eliminate_preferred_feature,
  :eliminate_possible_feature,
  :eliminate_almighty_feature
]

Instance Method Summary collapse

Constructor Details

#initialize(provider_piece, request_piece) ⇒ Eliminator

Returns a new instance of Eliminator.



240
241
242
243
 
# File 'lib/pione/lang/feature-expr.rb', line 240

def initialize(provider_piece, request_piece)
  @provider_piece = provider_piece
  @request_piece = request_piece
end

Instance Method Details

#eliminate ⇒ Object 



245
246
247
248
249
250
 
# File 'lib/pione/lang/feature-expr.rb', line 245

def eliminate
  OPERATIONS.inject([@provider_piece, @request_piece]) do |(ppiece, rpiece), elim|
    result, _ppiece, _rpiece = __send__(elim, ppiece, rpiece)
    result ? [_ppiece, _rpiece] : [ppiece, rpiece]
  end
end

#eliminate_almighty_feature(provider_piece, request_piece) ⇒ Object

Eliminate almighty feature.

Rule:

  • (** <- ) -> ( <- *)
  • (** <- *) -> ( <- *)


380
381
382
383
384
385
386
387
388
389
 
# File 'lib/pione/lang/feature-expr.rb', line 380

def eliminate_almighty_feature(provider_piece, request_piece)
  pclass = provider_piece.class
  rclass = request_piece.class

  if pclass == AlmightyFeature and (rclass == AlmightyFeature or rclass == EmptyFeature)
    return true, EmptyFeature.new, EmptyFeature.new
  end

  return false
end

#eliminate_blocking_feature(provider_piece, request_piece) ⇒ Object

Elimiate a blocking feature.

Rule:

  • (Γ <- -X & Δ) -> Γ & Δ


312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
 
# File 'lib/pione/lang/feature-expr.rb', line 312

def eliminate_blocking_feature(provider_piece, request_piece)
  ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
  rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]

  rpieces.each do |rpiece|
    next unless rpiece.kind_of?(BlockingFeature)

    # eliminate only if Γ dosen't include almighty features
    next if ppieces.any? {|ppiece| ppiece.is_a?(AlmightyFeature)}

    # eliminate only if Γ dosen't include same name features
    next if ppieces.any? {|ppiece| ppiece.name == rpiece.name && not(ppiece.kind_of?(rpiece.class))}

    # eliminate only if Δ dosen't include same name features
    next if rpieces.any? {|piece| rpiece.name == piece.name && not(piece.kind_of?(rpiece.class))}

    # eliminate
    return true, provider_piece, rebuild_feature(rpieces - [rpiece])
  end

  return false
end

#eliminate_possible_feature(provider_piece, request_piece) ⇒ Object

Eliminate a possible feature.

Rule:

  • (^X & Γ <- Δ) -> (Γ <- Δ)


355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
 
# File 'lib/pione/lang/feature-expr.rb', line 355

def eliminate_possible_feature(provider_piece, request_piece)
  ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
  rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]

  ppieces.each do |ppiece|
    next unless ppiece.kind_of?(PossibleFeature)

    # eliminate only if Γ dosen't include same symbol feature
    next if ppieces.any? {|piece| ppiece.name == piece.name && not(piece.kind_of?(ppiece.class))}

    # eliminate only if Δ dosen't include same symbol feature
    next if rpieces.any? {|rpiece| ppiece.name == rpiece.name && not(rpiece.kind_of?(ppiece.class))}

    # eliminate
    return true, rebuild_feature(ppieces - [ppiece]), request_piece
  end

  return false
end

#eliminate_preferred_feature(provider_piece, request_piece) ⇒ Object

Eliminate a preferred feature.

Rule:

  • (Γ <- ?X & Δ) -> (Γ <- Δ)


339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/pione/lang/feature-expr.rb', line 339

def eliminate_preferred_feature(provider_piece, request_piece)
  ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
  rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]

  if rpieces.any? {|e| e.kind_of?(PreferredFeature)}
    _request = rebuild_feature(rpieces.reject {|rpiece| rpiece.kind_of?(PreferredFeature)})
    return true, provider_piece, _request
  end

  return false
end

#eliminate_requisite_feature(provider_piece, request_piece) ⇒ Object

Eliminate a requisite feature from the request pieces. This is for the case that requisite feature is satisfied by possible feature or restrictive feature.

Rule:

  • (^X & Γ <- +X & Δ) -> Γ & Δ
  • (!X & Γ <- +X & Δ) -> Γ & Δ


259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/pione/lang/feature-expr.rb', line 259

def eliminate_requisite_feature(provider_piece, request_piece)
  ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
  rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]

  rpieces.each do |rpiece|
    # requisite feature is target
    next unless rpiece.kind_of?(RequisiteFeature)

    ppieces.each do |ppiece|
      next unless ppiece.kind_of?(PossibleFeature) || ppiece.kind_of?(RestrictiveFeature)
      next unless ppiece.name == rpiece.name

      # eliminate only if Γ dosen't include same symbol feature
      next if ppieces.any? {|piece| ppiece.name == piece.name && not(piece.kind_of?(ppiece.class))}

      # eliminate only if Δ dosen't include same symbol feature
      next if rpieces.any? {|piece| rpiece.name == piece.name && not(piece.kind_of?(rpiece.class))}

      # eliminate
      return true, rebuild_feature(ppieces - [ppiece]), rebuild_feature(rpieces - [rpiece])
    end
  end

  return false
end

#eliminate_requisite_feature_by_almighty_feature(provider_piece, request_piece) ⇒ Object

Eliminate request features by almighty feature.

Rule:

  • (** <- +X & Δ) -> (** <- Δ)


289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'lib/pione/lang/feature-expr.rb', line 289

def eliminate_requisite_feature_by_almighty_feature(provider_piece, request_piece)
  ppieces = provider_piece.is_a?(CompoundFeature) ? provider_piece.pieces : [provider_piece]
  rpieces = request_piece.is_a?(CompoundFeature) ? request_piece.pieces : [request_piece]

  rpieces.each do |rpiece|
    # requisite feature is target
    next unless rpiece.kind_of?(RequisiteFeature)

    ppieces.each do |ppiece|
      next unless ppiece.kind_of?(AlmightyFeature)

      # eliminate
      return true, provider_piece, rebuild_feature(rpieces - [rpiece])
    end
  end

  return false
end