/* Q1: do we want third-parties to create decorators? S: yes it may be possible, preferably as components J: why not? R: no A: essentially no, third-parties provide SDK and decorators available there can be used in the components Standa: no G: yes --------- no decision yet, but taking into account */ /* Q2: who creates them, for now it is source component (CreateDecoratedOutputItem(outputItem, inputItem) S: define an interface, IDecoratorFactory component and exchange item may decide to implement it when they need J: --||--||-- R: source component A: any possible way, preferably IExchangeItem, we always instantiate decorators from IExchangeItem.Create/whatever Standa: source component G: IDecoratorFactory, but note that only ILinkableComponent (and/or IExchangeItem) will asked by the gui if it implements it */ * --------------------------- current solution (there will be quesions): // query available/create interface IDecoratorFactory { IIdentifiable[] GetAvailableDecorators(IExchangeItem item, IExchangeItem target); IDescribable GetDecoratorDescription(IIdentifiable); IOutputDecorator CreateOutputDecorator(IIdentifiable decoratorId, IOutputItem item, IExchangeItem target); IInputDecorator CreateInputDecorator(IIdentifiable decoratorId, IInputItem item, IExchangeItem target); } interface ILinkableComponent { IDecoratorFactory GetDecoratorFactory(); } NOTE: Remove input decorators for now! ------------------------------------------- IExchangeItem IExchangeItem.GetAvailableDecorators(); * request available decorators from component ILinkableComponent.GetAvailableDecorator(IExchangeItem item); * create using factory IDecoratorFactory.GetAvailableDecorators(IExchangeItem item); * create somewhere else, e.g.: IOutputItem decorator = new MyCustomDecorator(outputItem); interface IDecoratorFactory { IIdentifiable[] GetAvailableDecorators(IExchangeItem item, IExchangeItem target); IDescribable GetDecoratorDescription(IIdentifiable); IOutputDecorator CreateOutputDecorator(IIdentifiable decoratorId, IOutputItem item, IExchangeItem target); IInputDecorator CreateInputDecorator(IIdentifiable decoratorId, IInputItem item, IExchangeItem target); } IExchangeItem { IDecoratorFactory GetDecoratorFactory(); } if(component is IDecoratorFactory) { var factory = (IDecoratorFactory)excahngeItem; } /* Q3: how can we re-use decorators!? inject them manually. It could be Q3.1: inside the component (code) S: we offer utilities to let the factories build decorators J: yes, add/remove operations for decorator should be available R: yes A: no, if they are from third-parties, because the provider dictates what decorators are available yes, if they're coming from the component Standa: yes, if they're coming from the component G: yes, when third-party decorators are injected - Component property will be set when decorator is added to the component. Q3.2: during configuration (forced by user!) S: just add them to the component.OutputItems (every created decorator will already have component) J: --||-- R: add then not via OutputItems.Add() but using another way (which?), add method to linkable component which will re-create given decorators A: having combination of Decorator.Id + exchange item being decorated Standa: yes G: yes */ * ILinkableComponent.AddDecorator(IDecoratedOutputItem decorator) ILinkableComponent.RemoveDecorator(IDecoratedOutputItem decorator) ILinkableComponent.AddDecorator(IDecoratedInputItem decorator) ILinkableComponent.RemoveDecorator(IDecoratedInputItem decorator) * add via exchange item IOutputItem.AddDecorator(IDecoratedOutputItem decorator) IOutputItem.RemoveDecorator(IDecoratedOutputItem decorator) IInputItem.AddDecorator(IDecoratedInputItem decorator) IInputItem.RemoveDecorator(IDecoratedInputItem decorator) Push/Pop (Add/Remove only at the end) AddLast/RemoveLast (see LinkedList in .NET) // add/remove ..... /* - how do we query them - where from? - how do we add/remove them */ public void CreateDecotarors() { ILinkableComponent sourceComponent = ...; ILinkableComponent targetComponent = ...; IOutputItem outputItem = sourceComponent.OutputItems[0]; IInputItem inputItem = targetComponent.InputItems[0]; IOutputItem decoratedOutputItem = <create>; } /* Q4: why can't we use decorators on input exchange items? S: we can, we should provide a mirror interface J: --||-- R: yes, IExchangeItemDecorator { IExhchangeItem DecoratedItem { get; } } A: yes, we can Standa: yes, probably mirror interface G: we should add it ----------- yes, we can Q5: can we use decorators without real components, just by generating output item and transforming it to another output item (important for tests) S: we can J: yes R: yes A: yes, we do need an exchange item Standa: for testing yes G: yes, it must be possible ---- yes, but no one could stop developer of the decorator to be used only in the context of the component, which owns item being decorated. Q6: it sounds nice to make a decorator know about component it decorates S: Decorator.Component is the owner component J: --||-- R: optional, when we use them independently (test) then it is not used A: not neccessary, I'd consider it redundant, there is always an exchange item and component is known by it Standa: yes G: yes, in the current interface it is Component property of the decorator ------ leave it for now Q7: can we use linkable components as/instead of decorators? S: no J: if instead - no, for something more advanced - yes, use as a separate components R: no A: we can't stop anybody to do it Standa: yes G: with the current solution we don't force it, but user's can wrap components as decorators ----------- yes, as a separate components connected to existing components Q8: when and where we provide consumer to the DecoratedOutputItem (IInputItem) S: we don't G: we don't J: we don't R: we don't A: we don't care :) Standa: we don't G: --||-- ------------- don't Q9: can we have 2 output items as input of a decorator, or 2 outputs? S: no, make a small component J: no R: yes, I'd prefer to do that A: yes, behind the scenes it may use anything from the component Standa: no, make it a component G: yes, but maybe in 3.0 (I'd not put too much effort now) ------------- not for now, for now it is 1 to 1, this is a special case */