de.fosd.typechef.featureexpr.sat

Not

class Not extends HashCachingFeatureExpr

Linear Supertypes
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Not
  2. HashCachingFeatureExpr
  3. SATFeatureExpr
  4. FeatureExpr
  5. Serializable
  6. AnyRef
  7. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Not(expr: SATFeatureExpr)

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any
  3. final def ##(): Int

    Definition Classes
    AnyRef → Any
  4. final def &(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  5. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  6. final def ==(arg0: Any): Boolean

    Definition Classes
    Any
  7. def and(that: FeatureExpr): FeatureExpr

    Definition Classes
    SATFeatureExprFeatureExpr
  8. final def andNot(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  9. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  10. val cachedHash: Int

    Attributes
    protected
    Definition Classes
    HashCachingFeatureExpr
  11. def calcCNF: SATFeatureExpr

    Attributes
    protected
    Definition Classes
    NotSATFeatureExpr
  12. def calcCNFEquiSat: SATFeatureExpr

    Attributes
    protected
    Definition Classes
    NotSATFeatureExpr
  13. def calcHashCode: Int

    Definition Classes
    NotSATFeatureExpr
  14. def calcSize: Int

    Definition Classes
    NotFeatureExpr
  15. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  16. def collectDistinctFeatureObjects: Set[SingleFeatureExpr]

    Definition Classes
    SATFeatureExprFeatureExpr
  17. def collectDistinctFeatures: Set[String]

    helper function for statistics and such that determines which features are involved in this feature expression

    helper function for statistics and such that determines which features are involved in this feature expression

    Definition Classes
    SATFeatureExprFeatureExpr
  18. def collectDistinctFeatures2: Set[DefinedExternal]

    Definition Classes
    SATFeatureExpr
  19. def countDistinctFeatures: Int

    counts the number of features in this expression for statistic purposes

    counts the number of features in this expression for statistic purposes

    Definition Classes
    SATFeatureExpr
  20. def debug_print(ind: Int): String

    Definition Classes
    NotFeatureExpr
  21. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  22. def equal1Level(that: SATFeatureExpr): Boolean

    Check structural equality, assuming that all component nodes have already been canonicalized.

    Check structural equality, assuming that all component nodes have already been canonicalized. The default implementation checks for pointer equality.

    Definition Classes
    NotSATFeatureExpr
  23. final def equals(that: Any): Boolean

    Definition Classes
    SATFeatureExpr → AnyRef → Any
  24. def equiv(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  25. def equivalentTo(that: FeatureExpr, fm: FeatureModel): Boolean

    Definition Classes
    FeatureExpr
  26. def equivalentTo(that: FeatureExpr): Boolean

    uses a SAT solver to determine whether two expressions are equivalent.

    uses a SAT solver to determine whether two expressions are equivalent.

    for performance reasons, it checks pointer equivalence first, but won't use the recursive equals on aexpr (there should only be few cases when equals is more accurate than eq, which are not worth the performance overhead)

    Definition Classes
    FeatureExpr
  27. def evaluate(selectedFeatures: Set[String]): Boolean

    evaluate the expression for a given feature selection (all features not provided are assumed deselected)

    evaluate the expression for a given feature selection (all features not provided are assumed deselected)

    features provided as a list of names (how they would be created with createDefinedExternal)

    evaluates to true or false

    Definition Classes
    NotSATFeatureExprFeatureExpr
  28. val expr: SATFeatureExpr

  29. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  30. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any
  31. def getConfIfSimpleAndExpr(): Option[(Set[SingleFeatureExpr], Set[SingleFeatureExpr])]

    NOT implemented, this method will always return None.

    NOT implemented, this method will always return None.

    returns
    Definition Classes
    SATFeatureExprFeatureExpr
  32. def getConfIfSimpleOrExpr(): Option[(Set[SingleFeatureExpr], Set[SingleFeatureExpr])]

    NOT implemented, this method will always return None.

    NOT implemented, this method will always return None.

    Definition Classes
    SATFeatureExprFeatureExpr
  33. def getSatisfiableAssignment(featureModel: FeatureModel, interestingFeatures: Set[SingleFeatureExpr], preferDisabledFeatures: Boolean): Option[(List[SingleFeatureExpr], List[SingleFeatureExpr])]

    Definition Classes
    SATFeatureExprFeatureExpr
  34. final def hashCode(): Int

    Definition Classes
    HashCachingFeatureExpr → AnyRef → Any
  35. def implies(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  36. def indent(level: Int): String

    Attributes
    protected
    Definition Classes
    FeatureExpr
  37. def isContradiction(fm: FeatureModel): Boolean

    Definition Classes
    FeatureExpr
  38. final def isContradiction(): Boolean

    Definition Classes
    FeatureExpr
  39. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  40. lazy val isResolved: Boolean

    checks whether there is some unresolved macro (DefinedMacro) somewhere in the expression tree

    checks whether there is some unresolved macro (DefinedMacro) somewhere in the expression tree

    Definition Classes
    SATFeatureExpr
  41. def isSatisfiable(fm: FeatureModel): Boolean

    x.

    x.isSatisfiable(fm) is short for x.and(fm).isSatisfiable but is faster because FM is cached

    Definition Classes
    SATFeatureExprFeatureExpr
  42. final def isSatisfiable(): Boolean

    Definition Classes
    FeatureExpr
  43. def isSmall(): Boolean

    heuristic to determine whether a feature expression is small (may be used to decide whether to inline it or not)

    heuristic to determine whether a feature expression is small (may be used to decide whether to inline it or not)

    use with care

    Definition Classes
    SATFeatureExpr
  44. def isTautology(fm: FeatureModel): Boolean

    FM -> X is tautology if FM.

    FM -> X is tautology if FM.implies(X).isTautology or !FM.and.(x.not).isSatisfiable

    not final for optimization purposes

    Definition Classes
    FeatureExpr
  45. final def isTautology(): Boolean

    Definition Classes
    FeatureExpr
  46. def mapDefinedExpr(f: (DefinedExpr) ⇒ SATFeatureExpr, cache: Map[SATFeatureExpr, SATFeatureExpr]): SATFeatureExpr

    map function that applies to all leafs in the feature expression (i.

    map function that applies to all leafs in the feature expression (i.e. all DefinedExpr nodes)

    Definition Classes
    NotSATFeatureExpr
  47. def mex(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  48. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef
  49. def not(): SATFeatureExpr

    Definition Classes
    SATFeatureExprFeatureExpr
  50. def notS(): SATFeatureExpr

    Definition Classes
    SATFeatureExpr
  51. final def notify(): Unit

    Definition Classes
    AnyRef
  52. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  53. def or(that: FeatureExpr): FeatureExpr

    Definition Classes
    SATFeatureExprFeatureExpr
  54. final def orNot(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  55. def print(p: Writer): Unit

    Prints the textual representation of this formula on a Writer.

    Prints the textual representation of this formula on a Writer. The result shall be equivalent to p.print(toTextExpr), but it should avoid consuming so much temporary space.

    p

    the output Writer

    Definition Classes
    NotFeatureExpr
  56. lazy val resolveToExternal: SATFeatureExpr

    replaces all DefinedMacro tokens by their full expansion.

    replaces all DefinedMacro tokens by their full expansion.

    the resulting feature expression contains only DefinedExternal nodes as leafs and can be printed and read again

    Definition Classes
    SATFeatureExpr
  57. final lazy val size: Int

    Definition Classes
    FeatureExpr
  58. def substitute(feature: SingleFeatureExpr, replacement: SATFeatureExpr): SATFeatureExpr

    Definition Classes
    NotSATFeatureExpr
  59. final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes
    AnyRef
  60. def toCNF(): SATFeatureExpr

    creates an equivalent feature expression in CNF

    creates an equivalent feature expression in CNF

    be aware of exponential explosion. consider using toCnfEquiSat instead if possible

    Definition Classes
    SATFeatureExpr
  61. def toCnfEquiSat(): SATFeatureExpr

    creates an equisatisfiable feature expression in CNF

    creates an equisatisfiable feature expression in CNF

    the result is not equivalent but will yield the same result in satisifiability tests with SAT solvers

    the algorithm introduces new variables and is faster than toCNF

    Definition Classes
    SATFeatureExpr
  62. def toString(): String

    Converts this formula to a textual expression.

    Converts this formula to a textual expression.

    Definition Classes
    NotFeatureExpr → AnyRef → Any
  63. def toTextExpr: String

    Definition Classes
    NotFeatureExpr
  64. final def unary_!: FeatureExpr

    Definition Classes
    FeatureExpr
  65. def unique(feature: SingleFeatureExpr): FeatureExpr

    unique existential quantification over feature "feature".

    unique existential quantification over feature "feature".

    This has the effect of substituting the feature by true and false respectively and returning the xor of both: this[feature->True] xor this[feature->False]

    It can be seen as identifying under which condition the feature matters for the result of the formula

    Definition Classes
    SATFeatureExprFeatureExpr
  66. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  67. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  68. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  69. def xor(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr
  70. final def |(that: FeatureExpr): FeatureExpr

    Definition Classes
    FeatureExpr

Inherited from HashCachingFeatureExpr

Inherited from SATFeatureExpr

Inherited from FeatureExpr

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped