final class EPK[+E <: Entity, +P <: Property] extends EOptionP[E, P]
- Alphabetic
- By Inheritance
- EPK
- EOptionP
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new EPK(e: E, pk: PropertyKey[P])
Value Members
- def asEPK: EPK[E, P]
- 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.
- def equals(other: Any): Boolean
- Definition Classes
- EPK → AnyRef → Any
- def hasLBP: Boolean
- final def hasNoLBP: Boolean
- Definition Classes
- EOptionP
- final def hasNoUBP: Boolean
- Definition Classes
- EOptionP
- def hasUBP: Boolean
- lazy val hashCode: Int
- Definition Classes
- EPK → 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
- def isEPK: Boolean
- 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. - val pk: PropertyKey[P]
The property key of the optionally available property.
- def toEPK: EPK.this.type
This EOptionP as a pair of an entity and a property key.
- def toEPS: Option[EPS[E, P]]
- def toString(): String
- Definition Classes
- EPK → AnyRef → Any
- def ub: Nothing
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.