class Pione::Lang::Eliminator

feature operations

Constants

OPERATIONS

Public Class Methods

new(provider_piece, request_piece) click to toggle source
# File lib/pione/lang/feature-expr.rb, line 239
def initialize(provider_piece, request_piece)
  @provider_piece = provider_piece
  @request_piece = request_piece
end

Public Instance Methods

eliminate() click to toggle source
# File lib/pione/lang/feature-expr.rb, line 244
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) click to toggle source

Eliminate almighty feature.

Rule:

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

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

# File lib/pione/lang/feature-expr.rb, line 379
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) click to toggle source

Elimiate a blocking feature.

Rule:

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

# File lib/pione/lang/feature-expr.rb, line 311
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) click to toggle source

Eliminate a possible feature.

Rule:

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

# File lib/pione/lang/feature-expr.rb, line 354
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) click to toggle source

Eliminate a preferred feature.

Rule:

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

# File lib/pione/lang/feature-expr.rb, line 338
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) click to toggle source

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 & Δ) -> Γ & Δ

# File lib/pione/lang/feature-expr.rb, line 258
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) click to toggle source

Eliminate request features by almighty feature.

Rule:

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

# File lib/pione/lang/feature-expr.rb, line 288
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

Private Instance Methods

rebuild_feature(pieces) click to toggle source
# File lib/pione/lang/feature-expr.rb, line 392
def rebuild_feature(pieces)
  case pieces.size
  when 0
    EmptyFeature.new
  when 1
    pieces.first
  else
    CompoundFeature.new(pieces: pieces)
  end
end