The Composition Filters model

1. The Composition Filters model Presented by Gitit Amihud

2. String firstName String lastName Date birthDate Address home The Person class setFirstName(String) String getFirstName() setLastName(String) String getLasttName() . . . We want to add method getPresent(Thing). but we want to enable calling it only on the Person’s birthday. we want to control the use of this method, depends on the state of the object

3. The solution: Composition Filters

4. Topics: • Characteristics • The Principle of message filtering • the filter structure • Filter elements • Filters types • The Interface • Pseudo variables • Examples

5. The Composition Filter model • The composition-filters object model extends the kernel object model. • The extension is at the interface level and includes input and output filters. • The Input filters deal with the messages that are received by the object, whereas output filters deal with the messages that are sent by the object.

6. methods Instance Variables The extension of the object model

7. Characteristics of the Composition Filter model Modular extension - filter can be attached to a class without modifying the definition of that class. Orthogonal extension – each filter extension to a class is independent from other filter extension. it allows easy composition of multiple filters. Declarative– A filter specification describes what it means but not how it is implemented.

8. The Principle of message filtering

9. The Filter structure Filter name : filter type = { Filter elements { Each filter consists of an ordered set of filter elements. A filter element consists of three parts: Condition => {matching part} {substitution part}

10. Filter element Condition => {matching part} {substitution part} o Condition- specifies a necessary condition to be fulfilled in order to continue the evaluation of a filter element: if the condition evaluates to false, the filter will reject the message and continue according to the rejection behavior if the condition evaluates to true the filter proceeds (sometimes it means sending error…). the default condition is True.

11. Filter element (cont) Condition => {matching part} {substitution part} o the enable operator =>–causes the acceptance of every message that matches the matching part. the exclusion operator ~> - causes the acceptance of any message except for the massages that matches the matching part. the default operator is the enable operator o A matching part - the evaluated message is matched against a pattern consisting of a message selector and a target specification (Target.Selector). the target and the selector can be replaced by wild card if there are more then one pattern The message is applied to each of them, from left to right, until a match has occurred.

12. Filter element (cont) Condition => {matching part} {substitution part} o A substitution part -specifies replacement values for the target and selector of the message. If the substitution part is a wild card, the target and selector remain unchanged. for example: IsBirthday => *.getPresent *.*

13. Filter types • Error filter • Dispatch filter • Substitution filter • Send filter • Wait filter • Meta filter (later)

14. Filter types (cont) Error filter Used for: restriction of class interface. This filter can be used to implement pre conditions and view partitioning. Used in: Input/Output filter set. Accept handler: The accepted message proceeds to the next filter. Reject handler: The rejected message is regarded as illegal and the program raises an exception stating where the exception occurred. parameters: none. for example: select: Error = { IsBirthday =>[*.getPresent]*.*}

15. Filter types (cont) Dispatch filter Used for: initiation of a message execution. The dispatch filter introduces ‘inheritance’ by delegation. Used in: input filter set. Accept handler: The accepted message is delegated to the target object, or executed if target object is inner. Reject handler: The rejected message continues to the next filter. Parameters: none. for example: disp: Dispatch = {True =>inner.*, someclass.* };

16. Filter types (cont) substitution filter Used for: substitution of the target, selector or target and selector of the message. Used in: Input/Output filter set. Accept handler: The accepted message is substituted by the target and selector specified in the parameter part. Reject handler: The rejected message continues to the next filter. Parameters: the new target and/or selector.

17. Filter types (cont) Send filter Used for: initiation of a message delegation. Used in: Output filter set. Accept handler: The accepted message is passed to another object outside the sending object. Reject handler: The rejected message continues to the next filter. Parameters: none.

18. Filter types (cont) Wait filter Used for: concurrency control and synchronization. Used in: Input/Output filter set. Accept handler: The accepted message continues to the next filter. Reject handler: The rejected message is blocked until one or more conditions are satisfied. The message is then re- evaluated by the wait filter. Parameters: none.

19. The interface Class Example interface Internals Externals Conditions Methods Input filters Output filters End;

20. The interface (cont) Internals Fully encapsulated objects, used to compose the behavior of the cf object. they are created when their encapsulating object is created. Externals objects that exist outside the composition filter object, such as global objects. since they lay outside the object in which they are declared, they have to be passed to the cf object when it is created. Conditions typically represent an object’s state, used in a filter to test whether a message should be accepted or rejected. condition are methods without parameters, return boolean and should be free of side effects.

21. The interface (cont) Methods the name of the methods that are available to other objects (visible on the interface). Input filters filters for inspecting and manipulating incoming messages. Output filters filters for inspecting and manipulating outgoing messages.

22. Composition Filtermodel

23. The Person class • class Person interface • /* no internals */ • /* no externals */ • conditions • isBirthday; • isLocal; • methods • getFullName(Boolean) returns String • getPresent(Thing) returns Nil • inputfilters • select: Error = { True => [*. getFullName]*.*, IsBirthday =>[*.getPresent]*.*}, • disp: Dispatch = {inner.* }; • /* no outputfilters */ • end;

24. Pseudo variables • Sender • Server • Self • Inner • Message

25. Pseudo variables(cont) Sender the object that was responsible for sending the current executed message. Server the original receiver of the message that caused the current execution. Self the object that executes the current method.

26. Pseudo variables(cont) Inner the kernel, implementation part of the current object. Message the message that caused the current execution.

28. Pseudo variables (cont) 1-sender 2-server 3-self 4-inner 5-message

29. Dynamic inheritance Designate a mechanism that allows for enabling and disabling an inheritance relation with a superclass at runtime • class Secretary interface • internals • work : Employee; • private : Spouse; • conditions • WorkHours; OffTime; • methods • schedule(Appointment) returns Boolean; • Inputfilters • dynInh : Dispatch = {WorkHours=>inner.*, OffTime=>private.*, WorkHours=>work.*}; end

30. Multiple views class Clerk interface internals empl : Employee; externals administrator : Secretary; conditions SentByManager begin return sender.isSubTypeOf(Manager); end; SentBySecretary begin return sender=administrator; end; methods getWorkingHours returns WorkingHours setWorkingHours(WorkingHours) returns Nil inputfilters select : Error = { SentByManager=>putTask, {SentByManager, SentBySecretary}=>getWorkingHours, True~>{putTask, getWorkingHours} }; delegate : Dispatch = { inner.*, empl.*, administrator.schedule }; end

31. Filter types: Meta filter Meta filter Used for: reflection on object interactions. Used in: Input/Output filter set. Accept handler: The accepted message is reified (converted to an instance of class Message and then passed as an argument ) and delegated to a meta object. Reject handler: The rejected message continues to the next filter. Parameters: the target meta object and the selector of the function to be called.

32. Filter types: Meta filter (cont) class LoggedClerk interface internals clerk : Clerk; // inherit from clerk externals bigBrother : LogACT; // this declares an external ACT object inputfilters reifyIn : Meta = { [*.*]bigBrother.logMessage }; // reify and send message to the ACT inherit : Dispatch = { clerk.* }; outputfilters reifyOut : Meta = { [*.*]bigBrother.logMessage }; // reify and send message to the ACT end

33. Filter types: Meta filter (cont) class LogACT interface comment "this class logs all the received meta-messages, and fires them again" ; methods logMessage(Message) returns Nil; Inputfilters disp : Dispatch = {inner.* }; end;

34. Filter types: Meta filter (cont) class LogACT implementation instvars log : OrderedCollection; methods logMessage(mess : Message) returns Nil begin log.addLast(mess); mess.fire; end; end; // class LogACT implementation

35. Lodewijk Bergmans, The composition Filters object model • Lodewijk Bergmans & Mehmet Aksit .Composing multiple concerns using Composition Filters • Mehmet Aksit & Bedir Tekinerdogan. Solving the modeling problems of object-oriented languages by composing multiple aspects using Composition Filters.