Package org.faktorips.runtime

Interface IDeltaComputationOptions

All Known Implementing Classes:
DeltaComputationOptionsByPosition
public interface IDeltaComputationOptions
Callback interface for the delta computation.
Author:
Jan Ortmann

  • Method Details

    • getMethod

      IDeltaComputationOptions.ComputationMethod getMethod(String association)
      Returns if the delta computation computes child deltas per position/index or per object.

      1. Example for a 1-many association: A contract version A has three coverages c0, c1, and c2. A second version B of the same contract has a new coverage cNew inserted between coverage c0 and c1. The coverages c0, c1,and c2 are unchanged except for their position.

      If this method returns IDeltaComputationOptions.ComputationMethod.BY_POSITION, the following deltas are computed.

      • position 0: version A:c0, version B:c0 ⇒ empty delta
      • position 1: version A:c1, version B:cNew ⇒ changed
      • position 2: version A:c2, version B:c1 ⇒ changed
      • position 3: version A:none, version B:c2 ⇒ added
      If this method returns IDeltaComputationOptions.ComputationMethod.BY_OBJECT, the following deltas are computed.
      • c0: version A:position 0, version B:position 0 ⇒ empty delta
      • c1: version A:position 1, version B:position 2 ⇒ moved
      • c2: version A:position 2, version B:position 3 ⇒ moved
      • cNew: version A:position none, version B:position 1 ⇒ added

      2. Example for a 1-many association: Same scenario as above, but now c1 is removed and no coverage is added.

      If this method returns IDeltaComputationOptions.ComputationMethod.BY_POSITION, the following deltas are computed.

      • position 0: version A:c0, version B:c0 ⇒ empty delta
      • position 1: version A:c1, version B:v2 ⇒ changed
      • position 2: version A:c2, version B:none ⇒ removed

      If this method returns IDeltaComputationOptions.ComputationMethod.BY_OBJECT, the following deltas are computed.

      • c0: version A:position 0, version B:position 0 ⇒ empty delta
      • c1: version A:position 1, version B:position none ⇒ removed
      • c2: version A:position 2, version B:position 1 ⇒ moved
      Example for a 1-1 association: A contract version A has the insured person p0. A second contract version B has the insured person p1.

      If this method returns IDeltaComputationOptions.ComputationMethod.BY_POSITION, the following delta is computed.

      • position 0: changed
      If this method returns IDeltaComputationOptions.ComputationMethod.BY_OBJECT, the following deltas are computed.
      • p0: removed
      • p1: added

    • isSame

      boolean isSame(IModelObject object1, IModelObject object2)
      Returns true if the two objects represent the same conceptual object, otherwise false. What the conceptual object is, depends on the use case in that you need the delta computation and on your object model.

      If the objects are for example contract versions, they represent the same contract, just at different point in times. In this case the check has to compare the contract numbers but ignore the version numbers. If the objects are coverages you might consider them the same, if they are of the same coverage type, e.g. both are accidental damages coverages.

    • ignore

      boolean ignore(Class<?> clazz, String property)
      Returns true if the given property should be ignored in the delta computation. If you compare for example two versions of the same contract, you might want to ignore the different in the creation time, as otherwise two versions would always be different.
      Parameters:
      clazz - The class the property belongs to.
      property - The name of the property.

    • isCreateSubtreeDelta

      boolean isCreateSubtreeDelta()
      Controls whether delta objects for added or removed subtree elements should be created explicitly.

      This method returns true if a delta should be created for added or removed subtrees. If this method returns false a delta is only created for the root of an added or removed subtree. For non-composition associations, this property is ignored because such associated objects are never processed recursively.

      The creation of delta elements for subtree nodes is based on reflection and may cause a performance issue if used in massive delta computation with many added or removed subtrees.

      Returns:
      true if a delta should be created for every element of an added or removed subtree.
      Since:
      3.15

    • areValuesEqual

      boolean areValuesEqual(Class<?> clazz, String property, Object value1, Object value2)
      Compares two values for equality by the given model class and property, where either one or both values may be null.
      Parameters:
      clazz - The class the property belongs to.
      property - The name of the property.
      value1 - The first value to compare
      value2 - The second value to compare
      Returns:
      true if the values are the same

    • ignoreAssociations

      boolean ignoreAssociations()
      Controls whether associations should be ignored when computing deltas. If set to true, only parent-to-child relations will be included.
      Returns:
      whether associations should be ignored.
      Since:
      19.12

    • ignoreMoved

      default boolean ignoreMoved()
      Controls whether moved associations should be ignored when computing deltas. If set to true, moved associations are treated as unchanged as long as they don't contain any other changes.

      Associations are only considered moved when the delta computation method is set to BY_OBJECT.

      Returns:
      whether moved associations should be ignored.
      Since:
      22.6