Mark I. Dinges wrote:
When processing the intents at each level and putting them into the
model. Would it be a better idea to push them the whole way down to
the operation model object or to leave them at the various levels in
the model and have the merge of the intents performed later?
Jean-Sebastien Delfino wrote:
Mark I. Dinges wrote:
I was going to start working on the annotation processing for
@Requires. Has anyone started working on it yet? Looking at the
current processing of the DataType annotation, it looks like we want
to create a PolicyJavaInterfaceProcessor class and register it with
the JavaInterfaceProcessorRegistryImpl. This way it will be call
during the introspection of the Java implementation.
PolicyJavaInterfaceProcessor would handle the @Requires and
@PolicySets annotations. Initial implementation will only handle the
@Requires. Any suggestions, comments, or recommendations?
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
I don't think that anyone has started to work on this, so Thanks for
volunteering :)
What you describe sounds good to me. I suggest to implement this in a
self contained policy annotation support module as it'll make it
easier to integrate.
You may want to check the Intent class as I'm not sure it's in sync
yet with the SCA 1.0 spec.
You'll need to handle both interfaces and implementation classes,
which both can have @Requires. I would expect @Requires on a Java
implementation class and its interfaces to translate to Intent
metadata in the ComponentType model describing the implementation.
A Java interface can also be specified in a service or reference for
a particular component (independent of the implementation class and
the interfaces it implements). You may have to handle that too and
translate @Requires to Intent metadata in the Component model
describing the particular component (somehow refining the Intents
specified on the implementation). This is something to investigate as
I couldn't find a clear description of the behavior in this case in
the SCA Java C&I spec.
Let us know if you run into any issues or questions.
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
Mark,
I would suggest to start with a model as an accurate representation of
the input assembly (without pushing intents down to the operation level,
and also without trying to reconcile intents at the constrainingType,
componentType, implementation, component, composite level), and defer
the determination of the intents at each concrete operation level to a
later point, to the runtime build phase for example. This will avoid
duplication of the intent info at each level and will give you the
ability to determine the actual intents with all the info from the
various places (the 5 levels I listed above) in hand, later.
--
Jean-Sebastien
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
