Difference between revisions of "Replication"

Revision as of 12:55, 23 January 2007

Author: Matthias Konrad

Related articles:

• A discussion on unfolded forms in the ECMA standard: ECMA_unfolded.
• A mathematical model for Eiffels dynamic binding: DynBindModel.
• An example instantiation of the the dynamic binding model: DynBindModelExamples.

Known problems of the following text: Calls to targets of type like Current do not include usage of an attribute when it is assigned to.

Introduction

One definition of replication is: the action or process of reproducing or duplicating.

Both ETL, OOSC2 and the standard use the term replication as if its semantics were common knowledge. I disagree to that, since I was not able to get consistent information about replication from notable experts. Hence it is certainly a term to be defined much more carefully.

Although not explicitly stated, it seems that a replicated feature has an unfolded form. That would mean, that we could get rid of replication by reducing it to other language mechanisms (As it is done for precursors). This is how the current ISE compiler (5.7 and earlier) handles replication (won't help us here since it doesn't comply to the standard).

If an unfolded form cannot be found, this has a huge impact on the standards text. The semantics of unqualified calls in the context of replicated features would for example not be defined.

Talking about features

Before digging into the replication rules we need a clear understanding of a feature.

There is a one to one connection between feature and Feature_body. Every feature has exactly one body. Every body belongs to exactly one feature. Meaning that, two different bodies belong to two different features and two different features have two different bodies.

Have a look at this example:

class
   B
feature
   f do ... end
end

class
   D
inherit
   B
      rename f as f1 select f1 end
   B
      rename f as f2 redefine f2 end
feature
   f2 do ... end
end

The following sentences apply to the above system:

• The system has two features.
• The feature named f1 in class D and the feature named f in class B are one and the same feature.
• Feature f1 of class D and feature f of class B are the same feature.
• Feature f2 of class D or the feature named f2 in class D. This feature has its body defined in class D.

By saying feature, we indirectly reference a certain Feature_body. Indirectly, because we can say: "feature f of a class D", when the Feature_body of f belongs to an Ancestor class A of D (Given that f is not redeclared on the inheritance path between A and D).

The name of feature f is always the name stated in its Feature_body. A feature may have different names in different classes (through renaming). It is thus legal to say: "Feature f with name fn in class D", when feature f is renamed to fn somewhere along the according inheritance path.

When we talk about feature bodies we are not strictly bound to the bodies occurring in the programs text. We may also denote the bodies that are results of folded forms. Examples are the body of a synonym or the body of a call-equivalent of an inline-agent or the body of a replicate as we will later see.

Version

A version of a feature f is a feature f2 different from f that is a redeclaration from either f or a version of f.

Talking about replicates

The term feature is now clear. A replicated features seems to be just an other feature. But where is its body? In the above Eiffel system there is certainly some replication going on. But there are no bodies for those replicated features.

This informal reasoning suggests that a replicated feature should be defined by an unfolded form. Given that this is defined, there is finally something like a replicated feature. Every replicated feature has a feature from which it is replicated from. It could be said, feature r is a replicate of feature f or feature r is replicated from feature f.

There is an other problem, it needs to be defined, when there is a need for a replicated feature of a certain feature. Altogether there are two things left to be defined.

When is a replicated feature needed

If a class has two feature names that refer to the same feature, both features need to be replicated. If a class has two features f1 and f2 where f2 is a version of f1 then feature f1 needs to be replicated.

For the above Eiffel system with classes B and D there is a need for replication. The feature with name f2 in class D is a version of the feature with name f1 in D.

The replicated feature

The replicated feature r of a feature f is a redeclaration of f. The body of r is almost a copy of feature f. But some feature names need to be renamed. In principal it is a transposition of feature f to the class in which the replication is needed. How exactly the transposition is done needs some thought. Here some examples should give a general understanding.

In the following system:

class
   B
feature
   f do g end
   g do ... end
 
end

class
   D
inherit
   B
      rename f as f1, rename g as g1, select f1, g1 end
   B
      rename f as f2, g as g2 end 
end

New and modified rules

In the following a set of rules are given that are meant to replace rules 8.16.2 through 8.16.5.

8.16.2 Semantics: Repeated Inheritance rule

This rule will be obsolete but some thing similar might be introduced as informal text.

8.16.3 Definition: Replication, Replica

Let:

• Class D have a parent part P1 that lists class B1.
• f be an effective feature of class B1. (????????????)
• Let P1 be such, that it changes the name of feature f to rn (With our without renaming) but doesn't have a redefine clause for rn.

The feature r of class D with name fn is replicated iif one of the following holds:

• Class D has a parent part P2 (different from P1) that lists class B2, such that B2 contains feature f and P2 changes its name to rn2 (different from rn) but doesn't redefine it.
• Class D has a feature g different from r that is a version of feature f.

So feature r is either replicated and is thus called a replica of feature f. When it is not replicated, feature f and r are the same (Not just equal, but one and the same feature).

Informal:

• Example:

class
   B
feature
   f do ... end
end

class
   C
inherit
   B
      rename f as f1 redefine f1 end
feature
   f1 do ... end
end

class
   D
inherit
   C
      select f1 end
   B 
      rename f as f2 redefine f2 end
   B
      rename f as f3 end
feature
   f2 do ... end
end

• Feature f1 of class D is not replicated in class D.
• Feature f2 of class D is not replicated in class D.
• Feature f3 of class D is replicated in class D. Feature f3 of class D is a replica of feature f of class B

8.16.X Validity: replicated feature

Let:

• Feature r with name rn of class D be a replica of feature f defined in class A.
• P1...Pn be the parent clauses that list classes B1...Bn that contain feature f such that P1...Pn change the name of f to rn.
• IP be the subsets of inheritance paths from A to D that enter D through one of P1...Pn.

Feature r is a valid replicate if every feature-name m that is used in f on a target of type like Current holds the following:

• The feature-name m is ultimately renamed to the same name along all the paths of IP.

Informal:

• Example:

class
   B
feature
   f do g end
   g do ... end
 
end

class
   D
inherit
   B
      rename f as f1, rename g as g1, select f1, g1 end
   B
      rename f as f2, g as g2 end 
   B
      rename f as f2, g as g3 end
feature
   f1 do ... end
end

There are several features that are replicated in D: f1, g1, f2, g2, g3. Only f2 is not a valid replicated feature in D. It is inherited through the second and third parent part and has a call to g (with target of type like Current). Since g of class B is inherited with a different name through the second and third parent part the system is not valid.

8.16.X Semantics: Replication

Let:

• Feature r with name rn in class D be the replica of a feature f.
• P1...Pn be the parent clauses of D that:
  • List classes that contain feature f.
  • Change the name of f to rn (with possible renaming).
  • Do not have a redefine rn clause.
• B be the class that contains the body of f.
• IP be one of the inheritance paths from B to D that enter D through the parent part P1.

The unfolded form of the replica r has a redefine rn clause in P1,...,Pn and a declaration with the following properties:

• It has the same signature as f.
• Its name is rn.
• Its body is a modified copy of the body of f but the feature names that are used with targets of type like current are renamed according to the renamings that occur on the inheritance path IP.
• It has no pre- or post-condition.

Informative:

• The validity rule of replicated features warrant, that all the inheritance paths from B over P1..Pn to D yield the the same renamings.

• Example:

class
   B
feature
   f do g end
   g do end
end

class
   D
inherit
   B
      rename f as f1, g as g1 redefine f1 select f1, g1 end
      rename f as f2, g as g2 end
feature
   f1 do ... end
end

The replicated features of class D are g1, f1 and g2. The following snippet shows class D replica unfolded:

class
   D
inherit
   B
      rename f as f1, g as g1 redefine f1, g1 select f1, g1 end
      rename f as f2, g as g2 redefine f2, g2 end
feature
   f1 do ... end 
   g1 do end    --I am a replica!
   f2 do g2 end --Me too
   g2 do end    --Me too
end

8.16.4 Validity: Call Sharing rule

(The rule described here would replace 8.16.4. Maybe an other name is needed for the rule)

It is valid for a feature f of class D that has its body defined in class B (this implies that f is not replicated in class D) to use feature g of class A on a target of type like Current if and only if there is exactly one version of g in D.

Informative:

• This rule implies one very simple property of calls to targets of type like Current, they are not influenced by selects.
• Example of an invalid System according to this rule:

class
   B
feature
   f
      do g end
   g  do ... end
end

class
   D
inherit
   B
      rename g as g1 redefine g1 select g1 end
   B
      rename g as g2 redefine g2 end
feature
   g1 do ... end
   g2 do ... end
end

Feature f is inherited by class D from ancestor A. The feature involves an unqualified call to feature g. Since feature g has two versions in D (g1 and g2) the system is invalid. If f would be renamed in one or both the parent parts, the system could be made valid.

8.16.5 Semantics: Replication Semantics rule

Rather than a semantic rule this is a consequence of all the not isolated features of a class being unfolded.