final class EPK[+E <: Entity, +P <: Property] extends EOptionP[E, P]
A simple pair consisting of an Entity and a PropertyKey.
- Alphabetic
- By Inheritance
- EPK
- EOptionP
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
- new EPK(e: E, pk: PropertyKey[P])
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- 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]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asInterim: InterimEP[E, P]
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @IntrinsicCandidate()
-
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.
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(other: Any): Boolean
- Definition Classes
- EPK → AnyRef → Any
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @IntrinsicCandidate()
- 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
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
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. -
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @IntrinsicCandidate()
-
val
pk: PropertyKey[P]
The property key of the optionally available property.
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
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. -
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
Deprecated Value Members
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] ) @Deprecated
- Deprecated