FeatureWeaving

The "FeatureWeaving" Interface

To be a valid FeatureDef object, your class must define the following methods (and include the TW.Features.FeatureWeaving Interface in its __implements__ attribute). See the section on WeavingTime? for the "big picture" of how these methods are used to assemble aspects into a component.

weaveFeature(self,name,item,maker,verticalContext)

Notification that a feature needs weaving.

• name -- the name of the feature to be woven
• item -- the object bound to name in the current source aspect layer
• maker -- the ComponentMaker? doing the weaving
• verticalContext -- a function which returns the name of its argument in the source aspect layer, or the argument itself if it is not found.

This message is sent when a FeatureDef is first detected (or defaulted) during weaving. If your FeatureDef wants to be called in every subsequent layer when an attribute named name is present, and at "finishing" time, it should install itself in the feature registry by executing:

            maker.features[name] = self

If you do not do this, the weaveFeature() message will be the only one your FeatureDef receives.

finishFeature(self,name,maker)

Last chance to affect the generated component.

• name -- the name of the feature
• maker -- the ComponentMaker? doing the weaving

This message is sent during the "finishing" phase of component construction, to all FeatureDefs which have registered themselves with the ComponentMaker?.

localDependencies(self,name,maker)

Return the names of other features this feature depends on.

• name -- the name of the feature
• maker -- the ComponentMaker? doing the weaving

Return: a sequence of names of features that must be finished before this feature is finished.

This method is called by the ComponentMaker? to build a dependency graph during the "finishing" phase. Features are "finished" in order based on their local dependencies (i.e., order between attributes of the same class).

globalDependencies(self,name,maker)

Return dependencies on features in the next outer class.

• name -- the name of the feature
• maker -- the ComponentMaker? doing the weaving

This method is used by certain features (notably the standard ClassFeature?) to calculate their localDependencies. It is not called by ComponentMakers directly. This method is required to exist so that features which create an instance of a class that's being woven, can force their containing class to be "finished" after the class that the feature wishes to instantiate. For example:

            class DiceService(Aspect):

                class RandomValueFeature:

                    def __init__(self,lo,hi):
                        self.lo = lo
                        self.hi = hi

                    def next(self):
                        print "Rolling from",self.lo,"to",self.hi
                        return randint(self.lo,self.hi)

                class DiceElement:

                    diceValue = FeatureExpression('RandomValueFeature(1,6)')

                    def roll(self):
                        return self.diceValue.next()

When the ComponentMaker? asks the ClassFeature? responsible for the DiceElement class what its localDependencies are, it will check the globalDependencies() of its contained features. Meanwhile, the FeatureExpression? class has a globalDependencies() method that will return the tuple ("RandomValueFeature",). Thus, the dependency graph for the classes will reflect DiceElement's dependency on RandomValueFeature, and they will be created in the right order at WeavingTime?.

XXX This would probably be a good place for a UML interaction diagram...