Packages

  • package root
    Definition Classes
    root
  • package org
    Definition Classes
    root
  • package opalj

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode.

    OPAL is a Scala-based framework for the static analysis, manipulation and creation of Java bytecode. OPAL is designed with performance, scalability and adaptability in mind.

    Its main components are:

    • a library (Common) which provides generally useful data-structures and algorithms for static analyses.
    • a framework for implementing lattice based static analyses (Static Analysis Infrastructure)
    • a framework for parsing Java bytecode (Bytecode Infrastructure) that can be used to create arbitrary representations.
    • a library to create a one-to-one in-memory representation of Java bytecode (Bytecode Disassembler).
    • a library to create a representation of Java bytecode that facilitates writing simple static analyses (Bytecode Representation - org.opalj.br).
    • a scalable, easily customizable framework for the abstract interpretation of Java bytecode (Abstract Interpretation Framework - org.opalj.ai).
    • a library to extract dependencies between code elements and to facilitate checking architecture definitions.
    • a library for the lightweight manipulation and creation of Java bytecode (Bytecode Assembler).

    General Design Decisions

    Thread Safety

    Unless explicitly noted, OPAL is thread safe. I.e., the classes defined by OPAL can be considered to be thread safe unless otherwise stated. (For example, it is possible to read and process class files concurrently without explicit synchronization on the client side.)

    No null Values

    Unless explicitly noted, OPAL does not null values I.e., fields that are accessible will never contain null values and methods will never return null. If a method accepts null as a value for a parameter or returns a null value it is always explicitly documented. In general, the behavior of methods that are passed null values is undefined unless explicitly documented.

    No Typecasts for Collections

    For efficiency reasons, OPAL sometimes uses mutable data-structures internally. After construction time, these data-structures are generally represented using their generic interfaces (e.g., scala.collection.{Set,Map}). However, a downcast (e.g., to add/remove elements) is always forbidden as it would effectively prevent thread-safety.

    Assertions

    OPAL makes heavy use of Scala's Assertion Facility to facilitate writing correct code. Hence, for production builds (after thorough testing(!)) it is highly recommend to build OPAL again using -Xdisable-assertions.

    Definition Classes
    org
  • package fpcf

    The fixpoint computations framework (fpcf) is a general framework to perform fixpoint computations of properties ordered by a lattice.

    The fixpoint computations framework (fpcf) is a general framework to perform fixpoint computations of properties ordered by a lattice. The framework in particular supports the development of static analyses.

    In this case, the fixpoint computations/static analyses are generally operating on the code and need to be executed until the computations have reached their (implicit) fixpoint. The fixpoint framework explicitly supports resolving cyclic dependencies/computations. A prime use case of the fixpoint framework are all those analyses that may interact with the results of other analyses.

    For example, an analysis that analyzes all field write accesses to determine if we can refine a field's type (for the purpose of the analysis) can (reuse) the information about the return types of methods, which however may depend on the refined field types.

    The framework is generic enough to facilitate the implementation of anytime algorithms.

    Definition Classes
    opalj
    Note

    This framework assumes that all data-structures (e.g., dependee lists and properties) that are passed to the framework are effectively immutable! (Effectively immutable means that a data structure is never updated after it was passed to the framework.)

    ,

    The dependency relation is as follows: “A depends on B” === “A is the depender, B is the dependee”. === “B is depended on by A”

    ,

    The very core of the framework is described in: Lattice Based Modularization of Static Analyses

  • package seq
    Definition Classes
    fpcf
  • HandleResultTask
  • OnFinalUpdateComputationTask
  • OnUpdateComputationTask
  • PKESequentialPropertyStore
  • PropertyComputationTask
  • PropertyStoreDependentTasksManager
  • QualifiedTask
  • SeqPropertyStore
  • TasksManager
c

org.opalj.fpcf.seq

SeqPropertyStore

abstract class SeqPropertyStore extends PropertyStore

Non-concurrent implementation of the property store.

Source
SeqPropertyStore.scala
Linear Supertypes
PropertyStore, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SeqPropertyStore
  2. PropertyStore
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new SeqPropertyStore()

Abstract Value Members

  1. abstract def MaxEvaluationDepth: Int
    Definition Classes
    PropertyStore
  2. abstract val ctx: Map[Class[_], AnyRef]

    Immutable map which stores the context objects given at initialization time.

    Immutable map which stores the context objects given at initialization time.

    Definition Classes
    PropertyStore
  3. abstract def doApply[E <: Entity, P <: Property](epk: EPK[E, P], e: E, pkId: Int): EOptionP[E, P]
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  4. abstract def doPreInitialize[E <: Entity, P <: Property](e: E, pk: PropertyKey[P])(pc: (EOptionP[E, P]) => InterimEP[E, P]): Unit
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  5. abstract def doRegisterTriggeredComputation[E <: Entity, P <: Property](pk: PropertyKey[P], pc: PropertyComputation[E]): Unit
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  6. abstract def doScheduleEagerComputationForEntity[E <: Entity](e: E)(pc: PropertyComputation[E]): Unit
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  7. abstract def doSet(e: Entity, p: Property): Unit
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  8. abstract def entities(propertyFilter: (SomeEPS) => Boolean): Iterator[Entity]

    The set of all entities which have an entity property state that passes the given filter.

    The set of all entities which have an entity property state that passes the given filter.

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  9. abstract def entities[P <: Property](lb: P, ub: P): Iterator[Entity]

    Returns all entities that currently have the given property bounds based on an "==" (equals) comparison.

    Returns all entities that currently have the given property bounds based on an "==" (equals) comparison. (In case of final properties the bounds are equal.) If some analysis only computes an upper or a lower bound and no final results exists, that entity will be ignored.

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  10. abstract def entities[P <: Property](pk: PropertyKey[P]): Iterator[EPS[Entity, P]]

    Returns all entities which have a property of the respective kind.

    Returns all entities which have a property of the respective kind. The result is undefined if this method is called while the property store still performs (concurrent) computations.

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  11. abstract def entitiesWithLB[P <: Property](lb: P): Iterator[Entity]

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  12. abstract def entitiesWithUB[P <: Property](ub: P): Iterator[Entity]

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  13. abstract def execute(f: => Unit): Unit

    Executes the given function at some point between now and the return of a subsequent call of waitOnPhaseCompletion.

    Executes the given function at some point between now and the return of a subsequent call of waitOnPhaseCompletion.

    Definition Classes
    PropertyStore
  14. abstract def fallbacksUsedForComputedPropertiesCount: Int

    The number of times a fallback property was computed for an entity though an (eager) analysis was actually scheduled.

    The number of times a fallback property was computed for an entity though an (eager) analysis was actually scheduled.

    Definition Classes
    PropertyStore
  15. abstract def force[E <: Entity, P <: Property](e: E, pk: PropertyKey[P]): Unit

    Enforce the evaluation of the specified property kind for the given entity, even if the property is computed lazily and no "eager computation" requires the results (anymore).

    Enforce the evaluation of the specified property kind for the given entity, even if the property is computed lazily and no "eager computation" requires the results (anymore). Using force is in particular necessary in cases where a specific analysis should be scheduled lazily because the computed information is not necessary for all entities, but strictly required for some elements. E.g., if you want to compute a property for some piece of code, but not for those elements of the used library that are strictly necessary. For example, if we want to compute the purity of the methods of a specific application, we may have to compute the property for some entities of the libraries, but we don't want to compute them for all.

    Definition Classes
    PropertyStore
    Note

    Triggers lazy evaluations.

  16. abstract def get[E <: Entity, P <: Property](epk: EPK[E, P]): Option[EOptionP[E, P]]

    Returns the property of the respective property kind pk currently associated with the given element e.

    Returns the property of the respective property kind pk currently associated with the given element e. Does not trigger any computations.

    Definition Classes
    PropertyStore
  17. abstract def get[E <: Entity, P <: Property](e: E, pk: PropertyKey[P]): Option[EOptionP[E, P]]

    Definition Classes
    PropertyStore
    See also

    get(epk:EPK) for details.

  18. abstract def handleResult(r: PropertyComputationResult): Unit

    Processes the result eventually; generally, not directly called by analyses.

    Processes the result eventually; generally, not directly called by analyses. If this function is directly called, the caller has to ensure that we don't have overlapping results and that the given result is a meaningful update of the previous property associated with the respective entity - if any!

    Definition Classes
    PropertyStore
    Exceptions thrown

    IllegalStateException If the result cannot be applied.

    Note

    If any computation resulted in an exception, then handleResult will fail and the exception related to the failing computation will be thrown again.

  19. abstract def hasProperty(e: Entity, pk: PropertyKind): Boolean

    See hasProperty(SomeEPK) for details.

    See hasProperty(SomeEPK) for details. *

    Definition Classes
    PropertyStore
  20. abstract def isIdle: Boolean

    Returns true if the store does not perform any computations at the time of this method call.

    Returns true if the store does not perform any computations at the time of this method call.

    This method is only intended to support bug detection.

    Definition Classes
    PropertyStore
  21. abstract def isKnown(e: Entity): Boolean

    Returns true if the given entity is known to the property store.

    Returns true if the given entity is known to the property store. Here, isKnown can mean

    • that we actually have a property, or
    • a computation is scheduled/running to compute some property, or
    • an analysis has a dependency on some (not yet finally computed) property, or
    • that the store just eagerly created the data structures necessary to associate properties with the entity because the entity was queried.
    Definition Classes
    PropertyStore
  22. implicit abstract val logContext: LogContext
    Definition Classes
    PropertyStore
  23. abstract def properties[E <: Entity](e: E): Iterator[EPS[E, Property]]

    Returns an iterator of the different properties associated with the given entity.

    Returns an iterator of the different properties associated with the given entity.

    This method is the preferred way to get a snapshot of all properties of an entity and should be used if you know that all properties are already computed.

    e

    An entity stored in the property store.

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  24. abstract def quiescenceCount: Int

    The number of times the property store reached quiescence.

    The number of times the property store reached quiescence.

    Definition Classes
    PropertyStore
  25. abstract def scheduledOnUpdateComputationsCount: Int

    The number of (OnUpdateContinuations) that were executed in response to an updated property.

    The number of (OnUpdateContinuations) that were executed in response to an updated property.

    Definition Classes
    PropertyStore
  26. abstract def scheduledTasksCount: Int

    Simple counter of the number of tasks that were executed to perform an initial computation of a property for some entity.

    Simple counter of the number of tasks that were executed to perform an initial computation of a property for some entity.

    Definition Classes
    PropertyStore
  27. abstract def shutdown(): Unit

    Should be called when a PropertyStore is no longer going to be used to schedule computations.

    Should be called when a PropertyStore is no longer going to be used to schedule computations.

    Properties can still be queried after shutdown.

    Definition Classes
    PropertyStore
  28. abstract def toString(printProperties: Boolean): String

    Returns a consistent snapshot of the stored properties.

    Returns a consistent snapshot of the stored properties.

    printProperties

    If true prints the properties of all entities.

    Definition Classes
    PropertyStore
    Note

    Some computations may still be running.

  29. abstract def waitOnPhaseCompletion(): Unit

    Awaits the completion of all property computations which were previously scheduled.

    Awaits the completion of all property computations which were previously scheduled. As soon as all initial computations have finished, dependencies on E/P pairs for which no value was computed, will be identified and the fallback value will be used. After that, the remaining intermediate values will be made final.

    Definition Classes
    PropertyStore
    Note

    If a computation fails with an exception, the property store will stop in due time and return the thrown exception. No strong guarantees are given which exception is returned in case of concurrent execution with multiple exceptions.

    ,

    In case of an exception, the analyses are aborted as fast as possible and the store is no longer usable.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def alreadyComputedPropertyKindIds: IntIterator
    Definition Classes
    PropertyStore
  5. def apply[E <: Entity, P <: Property](epk: EPK[E, P]): EOptionP[E, P]

    Returns the property of the respective property kind pk currently associated with the given element e.

    Returns the property of the respective property kind pk currently associated with the given element e.

    This is the most basic method to get some property and it is the preferred way if (a) you know that the property is already available – e.g., because some property computation function was strictly run before the current one – or if (b) the property is computed using a lazy property computation - or if (c) it may be possible to compute a final answer even if the property of the entity is not yet available.

    epk

    An entity/property key pair.

    returns

    EPK(e,pk) if information about the respective property is not (yet) available. Final|InterimP(e,Property) otherwise.

    Definition Classes
    PropertyStore
    Exceptions thrown

    IllegalStateException If setup phase was not called or a previous computation result contained an epk which was not queried. (Both state are ALWAYS illegal, but are only explicitly checked for if debug is turned on!)

    Note

    In general, the returned value may change over time but only such that it is strictly more precise.

    ,

    Querying a property may trigger the (lazy) computation of the property.

    ,

    setupPhase has to be called before calling apply!

    ,

    After all computations has finished one of the "pure" query methods (e.g., entities or get should be used.)

  6. final def apply[E <: Entity, P <: Property](e: E, pk: PropertyKey[P]): EOptionP[E, P]

    Definition Classes
    PropertyStore
    See also

    apply(epk:EPK) for details.

  7. final def apply[E <: Entity, P <: Property](es: Iterable[E], pmi: PropertyMetaInformation { type Self <: P }): Iterable[EOptionP[E, P]]

    Returns a snapshot of the properties with the given kind associated with the given entities.

    Returns a snapshot of the properties with the given kind associated with the given entities.

    Definition Classes
    PropertyStore
    Note

    Querying the properties of the given entities will trigger lazy computations.

    ,

    The returned collection can be used to create an InterimResult.

    See also

    apply(epk:EPK) for details.

  8. final def apply[E <: Entity, P <: Property](es: Iterable[E], pk: PropertyKey[P]): Iterable[EOptionP[E, P]]

    Returns a snapshot of the properties with the given kind associated with the given entities.

    Returns a snapshot of the properties with the given kind associated with the given entities.

    Definition Classes
    PropertyStore
    Note

    Querying the properties of the given entities will trigger lazy computations.

    ,

    The returned collection can be used to create an InterimResult.

    See also

    apply(epk:EPK) for details.

  9. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  10. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  11. def collectAndThrowException(t: Throwable): Nothing
    Attributes
    protected[fpcf]
    Definition Classes
    PropertyStore
    Annotations
    @inline()
  12. def collectException(t: Throwable): Unit
    Attributes
    protected[fpcf]
    Definition Classes
    PropertyStore
  13. def computeFallback[E <: Entity, P <: Property](e: E, pkId: Int): FinalEP[E, P]
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  14. final def context[T](key: Class[T]): T

    Looks up the context object of the given type.

    Looks up the context object of the given type. This is a comparatively expensive operation; the result should be cached.

    Definition Classes
    PropertyStore
  15. final val debug: Boolean

    If "debug" is true and we have an update related to an ordered property, we will then check if the update is correct!

    If "debug" is true and we have an update related to an ordered property, we will then check if the update is correct!

    Definition Classes
    PropertyStore
  16. var doTerminate: Boolean

    If set to true no new computations will be scheduled and running computations will be terminated.

    If set to true no new computations will be scheduled and running computations will be terminated. Afterwards, the store can be queried, but no new computations can be started.

    Definition Classes
    PropertyStore
  17. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  18. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  19. var exception: Throwable
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  20. def finalEntities[P <: Property](p: P): Iterator[Entity]

    Returns all final entities with the given property.

    Returns all final entities with the given property.

    Definition Classes
    PropertyStore
    Note

    Only to be called when the store is quiescent.

    ,

    Does not trigger lazy property computations.

  21. final def getAndClearInformation[T <: AnyRef](key: AnyRef): Option[T]

    Returns the information stored in the store and removes the key, if any.

    Returns the information stored in the store and removes the key, if any.

    This method is thread-safe. However, the client which adds information to the store has to ensure that the overall process of adding/querying/removing is well defined and the ordered is ensured.

    Definition Classes
    PropertyStore
  22. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  23. final def getInformation[T <: AnyRef](key: AnyRef): Option[T]

    Returns the information stored in the store, if any.

    Returns the information stored in the store, if any.

    This method is thread-safe. However, the client which adds information to the store has to ensure that the overall process of adding/querying/removing is well defined and the ordered is ensured.

    Definition Classes
    PropertyStore
  24. final def getOrCreateInformation[T <: AnyRef](key: AnyRef, f: => T): T

    Attaches or returns some information associated with the property store using a key object.

    Attaches or returns some information associated with the property store using a key object.

    This method is thread-safe. However, the client which adds information to the store has to ensure that the overall process of adding/querying/removing is well defined and the ordered is ensured.

    Definition Classes
    PropertyStore
  25. def handleExceptions[U](f: => U): U
    Definition Classes
    PropertyStore
    Annotations
    @inline()
  26. final def hasProperty(epk: SomeEPK): Boolean

    Tests if we have some (lb, ub or final) property for the entity with the respective kind.

    Tests if we have some (lb, ub or final) property for the entity with the respective kind. If hasProperty returns true a subsequent apply will return an EPS (not an EPK).

    Definition Classes
    PropertyStore
  27. final val hasSuppressedDependers: Array[Boolean]

    true if entities with a specific property kind (EP) may have dependers with suppressed notifications.

    true if entities with a specific property kind (EP) may have dependers with suppressed notifications. (I.e., suppressInteriumUpdates("depender")("EP") is true.)

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  28. var hasSuppressedNotifications: Boolean
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  29. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  30. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  31. final val lazyComputations: Array[SomeProperPropertyComputation]

    The set of computations that will only be scheduled if the result is required.

    The set of computations that will only be scheduled if the result is required.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  32. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  33. def newPhaseInitialized(propertyKindsComputedInThisPhase: Set[PropertyKind], propertyKindsComputedInLaterPhase: Set[PropertyKind], suppressInterimUpdates: Map[PropertyKind, Set[PropertyKind]], finalizationOrder: List[List[PropertyKind]]): Unit

    Called when a new phase was initialized.

    Called when a new phase was initialized. Intended to be overridden by subclasses if special handling is required.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  34. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  35. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  36. def onFirstException(t: Throwable): Unit

    Called when the first top-level exception occurs.

    Called when the first top-level exception occurs. Intended to be overridden by subclasses.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  37. final def preInitialize[E <: Entity, P <: Property](e: E, pk: PropertyKey[P])(pc: (EOptionP[E, P]) => InterimEP[E, P]): Unit

    Associates the given entity with the newly computed intermediate property P.

    Associates the given entity with the newly computed intermediate property P.

    Calling this method is only supported before any analysis is scheduled!

    pc

    A function which is given the current property of kind pk associated with e and which has to compute the new intermediate property p.

    Definition Classes
    PropertyStore
  38. final val propertyKindsComputedInEarlierPhase: Array[Boolean]

    If a property is queried for which we have no value, then this information is used to determine which kind of fallback is required.

    If a property is queried for which we have no value, then this information is used to determine which kind of fallback is required.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  39. final val propertyKindsComputedInLaterPhase: Array[Boolean]

    Used to identify situations where a property is queried, which is only going to be computed in the future - in this case, the specification of an analysis is broken!

    Used to identify situations where a property is queried, which is only going to be computed in the future - in this case, the specification of an analysis is broken!

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  40. final val propertyKindsComputedInThisPhase: Array[Boolean]
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  41. final def registerLazyPropertyComputation[E <: Entity, P <: Property](pk: PropertyKey[P], pc: ProperPropertyComputation[E]): Unit

    Registers a function that lazily computes a property for an element of the store if the property of the respective kind is requested.

    Registers a function that lazily computes a property for an element of the store if the property of the respective kind is requested. Hence, a first request of such a property will always first return no result.

    The computation is triggered by a(n in)direct call of this store's apply method.

    This store ensures that the property computation function pc is never invoked more than once for the same element at the same time. If pc is invoked again for a specific element then only because a dependee has changed!

    In general, the result can't be an IncrementalResult, a PartialResult or a NoResult.

    A lazy computation must never return a NoResult; if the entity cannot be processed an exception has to be thrown or the bottom value – if defined – has to be returned.

    Calling registerLazyPropertyComputation is only supported as long as the store is not queried and no computations are already running. In general, this requires that lazy property computations are scheduled before any eager analysis that potentially reads the value.

    Definition Classes
    PropertyStore
  42. final def registerTransformer[SourceP <: Property, TargetP <: Property, E <: Entity](sourcePK: PropertyKey[SourceP], targetPK: PropertyKey[TargetP])(pc: (E, SourceP) => FinalEP[E, TargetP]): Unit

    Registers a total function that takes a given final property and computes a new final property of a different kind; the function must not query the property store.

    Registers a total function that takes a given final property and computes a new final property of a different kind; the function must not query the property store. Furthermore, setupPhase must specify that notifications about interim updates have to be suppressed. A transformer is conceptually a special kind of lazy analysis.

    Definition Classes
    PropertyStore
  43. final def registerTriggeredComputation[E <: Entity, P <: Property](pk: PropertyKey[P], pc: PropertyComputation[E]): Unit

    Registers a property computation that is eagerly triggered when a property of the given kind is derived for some entity for the first time.

    Registers a property computation that is eagerly triggered when a property of the given kind is derived for some entity for the first time. Note, that the property computation function – as usual – has to be thread safe (only on-update continuation functions are guaranteed to be executed sequentially per E/PK pair). The primary use case is to kick-start the computation of some e/pk as soon as an entity "becomes relevant".

    In general, it also possible to have a standard analysis that just queries the properties of the respective entities and which maintains the list of dependees. However, if the list of dependees becomes larger and (at least initially) encompasses a significant fraction or even all entities of a specific kind, the overhead that is generated in the framework becomes very huge. In this case, it is way more efficient to register a triggered computation.

    For example, if you want to do some processing (kick-start further computations) related to methods that are reached, it is more efficient to register a property computation that is triggered when a method's Caller property is set. Please note, that the property computation is allowed to query and depend on the property that initially kicked-off the computation in the first place. Querying the property store may in particular be required to identify the reason why the property was set. For example, if the Caller property was set to the fallback due to a depending computation, it may be necessary to distinguish between the case "no callers" and "unknown callers"; in case of the final property "no callers" the result may very well be NoResult.

    pk

    The property key.

    pc

    The computation that is (potentially concurrently) called to kick-start a computation related to the given entity.

    Definition Classes
    PropertyStore
    Note

    A computation is guaranteed to be triggered exactly once for every e/pk pair that has a concrete property - even if the value was already associated with the e/pk pair before the registration is done.

  44. final def scheduleEagerComputationForEntity[E <: Entity](e: E)(pc: PropertyComputation[E]): Unit

    Schedules the execution of the given PropertyComputation function for the given entity.

    Schedules the execution of the given PropertyComputation function for the given entity. This is of particular interest to start an incremental computation (cf. IncrementalResult) which, e.g., processes the class hierarchy in a top-down manner.

    Definition Classes
    PropertyStore
    Note

    It is NOT possible to use scheduleEagerComputationForEntity for properties which are also computed by a lazy property computation; use force instead!

    ,

    If any computation resulted in an exception, then the scheduling will fail and the exception related to the failing computation will be thrown again.

  45. final def scheduleEagerComputationsForEntities[E <: Entity](es: IterableOnce[E])(c: PropertyComputation[E]): Unit

    Will call the given function c for all elements of es in parallel.

    Will call the given function c for all elements of es in parallel.

    Definition Classes
    PropertyStore
    See also

    scheduleEagerComputationForEntity for details.

  46. final def set(e: Entity, p: Property): Unit

    Associates the given property p, which has property kind pk, with the given entity e iff e has no property of the respective kind.

    Associates the given property p, which has property kind pk, with the given entity e iff e has no property of the respective kind. The set property is always final.

    Calling this method is only supported before any analysis is scheduled!

    One use case is an analysis that does use the property store while executing the analysis, but which wants to store the results in the store. Such an analysis must be executed before any other analysis is scheduled. A second use case are (eager or lazy) analyses, which want to store some pre-configured information in the property store; e.g., properties of natives methods which were derived beforehand.

    Definition Classes
    PropertyStore
    Note

    This method must not be used if there might be a computation (in the future) that computes the property kind pk for the given e.

  47. final def setupPhase(propertyKindsComputedInThisPhase: Set[PropertyKind], propertyKindsComputedInLaterPhase: Set[PropertyKind] = Set.empty, suppressInterimUpdates: Map[PropertyKind, Set[PropertyKind]] = Map.empty, finalizationOrder: List[List[PropertyKind]] = List.empty): Unit

    Needs to be called before an analysis is scheduled to inform the property store which properties will be computed now and which are computed in a later phase.

    Needs to be called before an analysis is scheduled to inform the property store which properties will be computed now and which are computed in a later phase. The information is used to decide when we use a fallback and which kind of fallback.

    propertyKindsComputedInThisPhase

    The kinds of properties for which we will schedule computations.

    propertyKindsComputedInLaterPhase

    The set of property kinds which will be computed in a later phase.

    suppressInterimUpdates

    Specifies which interim updates should not be passed to which kind of dependers. A depender will only be informed about the final update. The key of the map identifies the target of a notification about an update (the depender) and the value specifies which dependee updates should be ignored unless it is a final update. This is an optimization related to lazy computations, but also enables the implementation of transformers and the scheduling of analyses which compute different kinds of bounds unless the analyses have cyclic dependencies.

    Definition Classes
    PropertyStore
    Note

    setupPhase even needs to be called if just fallback values should be computed; in this case propertyKindsComputedInThisPhase and propertyKindsComputedInLaterPhase have to be empty, but finalizationOrder have to contain the respective property kind.

  48. final def setupPhase(configuration: PropertyKindsConfiguration): Unit
    Definition Classes
    PropertyStore
  49. def statistics: LinkedHashMap[String, Int]

    Reports core statistics; this method is only guaranteed to report final results if it is called while the store is quiescent.

    Reports core statistics; this method is only guaranteed to report final results if it is called while the store is quiescent.

    Definition Classes
    PropertyStore
  50. final var subPhaseFinalizationOrder: Array[List[PropertyKind]]

    The order in which the property kinds will be finalized; the last phase is considered the clean-up phase and will contain all remaining properties that were not explicitly finalized previously.

    The order in which the property kinds will be finalized; the last phase is considered the clean-up phase and will contain all remaining properties that were not explicitly finalized previously.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  51. var subPhaseId: Int
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  52. final val suppressInterimUpdates: Array[Array[Boolean]]
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  53. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  54. def toString(): String

    Returns a short string representation of the property store showing core figures.

    Returns a short string representation of the property store showing core figures.

    Definition Classes
    PropertyStore → AnyRef → Any
  55. final val traceFallbacks: Boolean
    Definition Classes
    PropertyStore
  56. final val traceSuppressedNotifications: Boolean
    Definition Classes
    PropertyStore
  57. final val transformersBySourcePK: Array[(PropertyKey[Property], (Entity, Property) => FinalEP[Entity, Property])]
    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  58. final val transformersByTargetPK: Array[(PropertyKey[Property], (Entity, Property) => FinalEP[Entity, Property])]

    The set of transformers that will only be executed when required.

    The set of transformers that will only be executed when required.

    Attributes
    protected[this]
    Definition Classes
    PropertyStore
  59. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  60. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  61. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from PropertyStore

Inherited from AnyRef

Inherited from Any

Ungrouped