final class InterimEUBP[+E <: Entity, +P <: Property] extends InterimEP[E, P]
- Source
- EOptionP.scala
- Alphabetic
- By Inheritance
- InterimEUBP
- InterimEP
- EPS
- EOptionP
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new InterimEUBP(e: E, ub: P)
Value Members
- def asEPK: EPK[E, P]
- final def asEPS: EPS[E, P]
This EOptionP as an EPS object; defined iff at least a preliminary property exists.
- def asFinal: FinalEP[E, P]
- def asInterim: InterimEP[E, P]
- val e: E
The entity.
The entity. E.g., a class, method or field. In general, it is recommended to use entities that stand for specific elements in the code, but which are not the concrete source code entities themselves. This greatly facilitates associating properties with entities where the respective code is not available. For example, by using an object which acts as a representative for a concrete method it is possible to associate (predetermined) properties with (selected) library methods even if those methods are not part of the analysis.
- Definition Classes
- InterimEUBP → EOptionP
- Note
Entities have to implement
equals/hashCodemethods which are very efficient, because entity based comparisons happen very frequently!
- def equals(other: Any): Boolean
- Definition Classes
- InterimEUBP → AnyRef → Any
- def hasLBP: Boolean
- returns
trueif the entity is associated with a (preliminary) property which represents a lower bound. Alwaystruein case of aFinalP.
- Definition Classes
- InterimEUBP → EOptionP
- final def hasNoLBP: Boolean
- Definition Classes
- EOptionP
- final def hasNoUBP: Boolean
- Definition Classes
- EOptionP
- def hasUBP: Boolean
- returns
trueif the entity is associated with a (preliminary) property which represents an upper bound. Alwaystruein case of aFinalP.
- Definition Classes
- InterimEUBP → EOptionP
- lazy val hashCode: Int
- Definition Classes
- InterimEUBP → AnyRef → Any
- def is(p: AnyRef): Boolean
Combines the test if we have a final property and – if we have one – if it is equal (by means of an equality check) to the given one.
Combines the test if we have a final property and – if we have one – if it is equal (by means of an equality check) to the given one.
- Definition Classes
- EOptionP
- final def isEPK: Boolean
- final def isEPS: Boolean
- def isFinal: Boolean
Returns
trueif and only if we have a property and the property was stored in the store using(Multi)Result. - final def isRefinable: Boolean
- Definition Classes
- EOptionP
- def lb: Nothing
Returns the lower bound of the property if it is available, otherwise an
UnsupportedOperationExceptionis thrown.Returns the lower bound of the property if it is available, otherwise an
UnsupportedOperationExceptionis thrown. For details regarding the precise semantics see the discussion for ub.- Definition Classes
- InterimEUBP → EOptionP
- Note
If the property is final, lb (and ub) will return the final property
p.
- lazy val pk: PropertyKey[P]
The property key of the optionally available property.
The property key of the optionally available property.
- Definition Classes
- InterimEUBP → EOptionP
- final def toEPK: EPK[E, P]
This EOptionP as a pair of an entity and a property key.
- final def toEPS: Option[EPS[E, P]]
- def toFinalELBP: FinalEP[E, P]
Creates a FinalP object using the current lb if the lb is available.
- def toFinalEUBP: FinalEP[E, P]
Creates a FinalP object using the current ub if the ub is available.
- def toString(): String
- Definition Classes
- InterimEUBP → AnyRef → Any
- val ub: P
Returns the upper bound of the property if it is available – hasUBP has to be
true– otherwise anUnsupportedOperationExceptionis thrown.Returns the upper bound of the property if it is available – hasUBP has to be
true– otherwise anUnsupportedOperationExceptionis thrown.The upper bound always models the best/most precise result w.r.t. the underlying lattice. Here, "best" means that the set of potentially reachable states/instructions that the analyzed program can ever assume is potentially smaller when compared to a worse property.
The upper bound models the sound and precise result under the assumption that the properties of all explicitly and implicitly relevant entities is as last queried or implicitly assumed. I.e., unless a dependee is updated the upper bound represents the correct and most precise result.
The lower bound models the worst case property that a specific entity can have under the assumption that all other relevant properties will get their worst properties. This can – but does not have to be – the underlying lattice's bottom value. The lower bound is generally helpful for client analyses to determine final results quicker. For example, imagine the following code:
def f(a : AnyRef) : Unit = a match { case a : List[_] => if (a.exists( _ == null)) throw new IllegalArgumentException case _ => throw new UnknownError } def m(){ try { f(List(1,2,3)) } catch { case nfe: NumberFormatException => ... } }
In that case – assuming we do not perform context sensitive analyses – if the lower bound for
ffor the set of thrown exceptions is determined to beSet(IllegalArgumentException,UnkownError), then the catch of theNumberFormatExceptioncan be ruled out and a final result formcan be computed.- Definition Classes
- InterimEUBP → EOptionP
- Note
If the property is final, lb (and ub) will return the final property
p.