So an algorithm that updates the static assembly model could be
something like...

Assumptions:

The model has had bindings copied up the implementation hierarchy
The model has had callback references and services created as appropriate
Indirectly attached policy sets have been applied to the model
G) will have been performed for non-composite component types

STEP 1 -  Starting at the bottom (lowest, leaf) level of the
implementation hierarchy, i.e. a component that is not implemented
with a composite.

For intents

For services, references  F)
For services, references and implementations A)
Applying C), D), E) in the process

For services, references and implementations H)
Applying I), J) in the process

For policy sets

For services, references and implementations H), K), A)
For services, references F) - not sure if this comes before or after H)

STEP 2 - Then for a composite that has the previous component as a child element

For intents and policy sets

For services, references G)
For services, references and implementations B)
Applying C), D), E) in the process

For services, references and implementations H)
Applying I), J) in the process

STEP 3 -  Repeat STEP 1 for any component that uses this composite as
an implementation

etc.

However this looks decidedly messy due to [POL40006] so I need to
ensure that I understand that correctly.

The CompositePolicyBuilderImpl code we currently have is doing some of
this on the fly to augment Endpoints and EndpointReferences but, IIUC,
assumes that the structural inheritance is already done.

The question then is should we do all this processing on the fly to
augment Endpoints and EndpointReferences or should we cache the
results of the processing on the assembly model? Not sure.. Maybe
there needs to be some halfway house given the model we have now. To
get it to work completely on the fly we do need the backward
structural hierarchy pointers.

I think Raymond was developing the "on the fly" approach so let's discuss.

Simon

Reply via email to