ConditionalLib

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def combine[T](r: Conditional[Conditional[T]]): Conditional[T]

helper function to collapse double conditionals Cond[Cond[T]] to Cond[T]

final def eq(arg0: AnyRef): Boolean

def equals[T](a: Conditional[T], b: Conditional[T]): Boolean

determines if two conditional values have equal value in all configurations

def equals(arg0: Any): Boolean

def equalsOp[T](a: Conditional[T], b: Conditional[T]): Boolean

alternative implementation with more satisifiability checks and potentially fewer comparisons

def explode[A, B](a: Conditional[A], b: Conditional[B]): Conditional[(A, B)]

combines entries from two conditional values to a conditional pair of values

def explodeOptList[T](l: List[Opt[T]]): Conditional[List[T]]

explodes a list of optional entries to choice of lists.

def finalize(): Unit

def flatten[T](optList: List[Opt[Conditional[T]]]): List[Opt[T]]

helper function to flatten optlists of conditionals into optlists without conditionals

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lastEntry[T](list: List[Opt[T]]): Conditional[Option[T]]

returns the last element (which may differ in different contexts) or None if the list is empty

def mapCombination[A, B, C](a: Conditional[A], b: Conditional[B], f: (A, B) ⇒ C): Conditional[C]

convenience function to map a function over all possible combinations of two conditional values

def mapCombinationOp[A, B, C](a: Conditional[A], b: Conditional[B], f: (A, B) ⇒ C): Conditional[C]

same as mapCombination, but additionally avoids (some) infeasible computations.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def vexplode[A, B](ctx: FeatureExpr, a: Conditional[A], b: Conditional[B]): Conditional[(A, B)]

def vfoldLeft[A, B](list: List[Opt[A]], init: Conditional[B], featureExpr: FeatureExpr, op: (FeatureExpr, B, A) ⇒ Conditional[B]): Conditional[B]

conditional fold, see vfoldRight

def vfoldRight[A, B](list: List[Opt[A]], init: Conditional[B], ctx: FeatureExpr, op: (FeatureExpr, A, B) ⇒ Conditional[B]): Conditional[B]

conditional implementation of a fold operation on lists with optional entries.

def vfoldRightR[A, B](list: List[Opt[A]], init: Conditional[B], op: (A, B) ⇒ Conditional[B]): Conditional[B]

conditional implementation of a fold operation on lists with optional entries.

def vfoldRightS[A, B](list: List[Opt[A]], init: Conditional[B], op: (A, B) ⇒ B): Conditional[B]

conditional implementation of a fold operation on lists with optional entries.

def vmapCombination[A, B, C](a: Conditional[A], b: Conditional[B], ctx: FeatureExpr, f: (FeatureExpr, A, B) ⇒ C): Conditional[C]

same as mapCombination, but additionally preserves a context during the computation

def vmapCombinationOp[A, B, C](a: Conditional[A], b: Conditional[B], ctx: FeatureExpr, f: (FeatureExpr, A, B) ⇒ C): Conditional[C]

same as vmapCombination, but additionally avoids (some) infeasible computations.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def compare[T, R](a: Conditional[T], b: Conditional[T], f: (T, T) ⇒ R): Conditional[R]

def conditionalFoldLeftFR: (List[Opt[Nothing]], Conditional[Nothing], FeatureExpr, (FeatureExpr, Nothing, Nothing) ⇒ Conditional[Nothing]) ⇒ Conditional[Nothing]

def conditionalFoldRight: (List[Opt[Nothing]], Conditional[Nothing], (Nothing, Nothing) ⇒ Nothing) ⇒ Conditional[Nothing]

def conditionalFoldRightFR: (List[Opt[Nothing]], Conditional[Nothing], FeatureExpr, (FeatureExpr, Nothing, Nothing) ⇒ Conditional[Nothing]) ⇒ Conditional[Nothing]

def conditionalFoldRightR: (List[Opt[Nothing]], Conditional[Nothing], (Nothing, Nothing) ⇒ Conditional[Nothing]) ⇒ Conditional[Nothing]

def findSubtree[T](ctx: FeatureExpr, value: Conditional[T]): Conditional[T]

def insert[T](t: Conditional[T], ctx: FeatureExpr, f: FeatureExpr, e: T): Conditional[T]

def isTrue(t: Conditional[Boolean]): FeatureExpr

def items[T](t: Conditional[T], ctx: FeatureExpr = FeatureExprFactory.True): List[(FeatureExpr, T)]

def leaves[T](t: Conditional[T]): List[T]

def mapCombinationF: (Conditional[Nothing], Conditional[Nothing], FeatureExpr, (FeatureExpr, Nothing, Nothing) ⇒ Nothing) ⇒ Conditional[Nothing]

def toList[T](c: Conditional[T]): List[(FeatureExpr, T)]

def toOptList[T](c: Conditional[T]): List[Opt[T]]