source: trunk/autoquest-core-usability-evaluation/src/main/java/de/ugoe/cs/autoquest/usability/rules/patterns/UsagePatternBuilder.java @ 1150

Last change on this file since 1150 was 1150, checked in by adeicke, 11 years ago

Added usage patterns and mechanism for detecting them.
  • Property svn:mime-type set to text/plain
File size: 20.4 KB
Line 
1//   Copyright 2012 Georg-August-Universität Göttingen, Germany
2//
3//   Licensed under the Apache License, Version 2.0 (the "License");
4//   you may not use this file except in compliance with the License.
5//   You may obtain a copy of the License at
6//
7//       http://www.apache.org/licenses/LICENSE-2.0
8//
9//   Unless required by applicable law or agreed to in writing, software
10//   distributed under the License is distributed on an "AS IS" BASIS,
11//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//   See the License for the specific language governing permissions and
13//   limitations under the License.
14
15package de.ugoe.cs.autoquest.usability.rules.patterns;
16
17import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsEventVisitor;
18import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.ContainsPatternVisitor;
19import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithEventVisitor;
20import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.EndsWithPatternVisitor;
21import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithEventVisitor;
22import de.ugoe.cs.autoquest.usability.rules.patterns.visitors.StartsWithPatternVisitor;
23import de.ugoe.cs.autoquest.usability.tasktree.filters.EventTypeFilter;
24import de.ugoe.cs.autoquest.usability.tasktree.filters.TaskTreeNodeTypeFilter;
25
26/**
27 * <p>
28 * TODO comment
29 * </p>
30 *
31 * @author Alexander Deicke
32 */
33public class UsagePatternBuilder {
34
35    protected TaskTreeNodeTypeFilter concernedNode;
36   
37    protected EventTypeFilter startsWithEvent;
38   
39    protected UsagePattern startsWithPattern;
40   
41    protected EventTypeFilter endsWithEvent;
42   
43    protected UsagePattern endsWithPattern;
44   
45    protected EventTypeFilter containsEvent;
46   
47    protected UsagePattern containsPattern;
48   
49    /**
50     * <p>
51     * TODO: comment
52     * </p>
53     *
54     * @param sequence
55     * @return
56     */
57    public SpecifyPatternStep concernedNode(TaskTreeNodeTypeFilter concernedNode) {
58        this.concernedNode = concernedNode;
59        return new SpecifyPatternStep();
60    }
61   
62    public class SpecifyPatternStep {
63
64        /**
65         * <p>
66         * TODO: comment
67         * </p>
68         *
69         * @param textInput
70         * @return
71         */
72        public BuildStartsWithEventStep startsWith(EventTypeFilter startsWithType) {
73            UsagePatternBuilder.this.startsWithEvent = startsWithType;
74            return new BuildStartsWithEventStep();
75        }
76       
77        /**
78         * <p>
79         * TODO: comment
80         * </p>
81         *
82         * @param startsWithPattern
83         * @return
84         */
85        public BuildStartsWithPatternStep startsWith(UsagePattern startsWithPattern) {
86            UsagePatternBuilder.this.startsWithPattern = startsWithPattern;
87            return new BuildStartsWithPatternStep();
88        }
89       
90        /**
91         * <p>
92         * TODO: comment
93         * </p>
94         *
95         * @param textInput
96         * @return
97         */
98        public BuildEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
99            UsagePatternBuilder.this.endsWithEvent = endsWithType;
100            return new BuildEndsWithEventStep();
101        }
102       
103        /**
104         * <p>
105         * TODO: comment
106         * </p>
107         *
108         * @param endsWithPattern
109         * @return
110         */
111        public BuildEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
112            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
113            return new BuildEndsWithPatternStep();
114        }
115
116        /**
117         * <p>
118         * TODO: comment
119         * </p>
120         *
121         * @param textInput
122         * @return
123         */
124        public BuildContainsEventStep contains(EventTypeFilter containsType) {
125            UsagePatternBuilder.this.containsEvent = containsType;
126            return new BuildContainsEventStep();
127        }
128
129        /**
130         * <p>
131         * TODO: comment
132         * </p>
133         *
134         * @param containsPattern
135         * @return
136         */
137        public BuildContainsPatternStep contains(UsagePattern containsPattern) {
138            UsagePatternBuilder.this.containsPattern = containsPattern;
139            return new BuildContainsPatternStep();
140        }
141       
142    }
143   
144    public class BuildStartsWithEventStep {
145
146        /**
147         * <p>
148         * TODO: comment
149         * </p>
150         *
151         * @param endsWithType
152         * @return
153         */
154        public BuildStartsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
155            UsagePatternBuilder.this.endsWithEvent = endsWithType;
156            return new BuildStartsAndEndsWithEventStep();
157        }
158       
159        /**
160         * <p>
161         * TODO: comment
162         * </p>
163         *
164         * @param endsWithPattern
165         * @return
166         */
167        public BuildStartsWithEventAndEndsWithPattern endsWith(UsagePattern endsWithPattern) {
168            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
169            return new BuildStartsWithEventAndEndsWithPattern();
170        }
171       
172        /**
173         * <p>
174         * TODO: comment
175         * </p>
176         *
177         * @param textInput
178         * @return
179         */
180        public BuildStartsWithEventAndContainsEventStep contains(EventTypeFilter containsType) {
181            UsagePatternBuilder.this.containsEvent = containsType;
182            return new BuildStartsWithEventAndContainsEventStep();
183        }
184       
185        /**
186         * <p>
187         * TODO: comment
188         * </p>
189         *
190         * @param containedPattern
191         * @return
192         */
193        public BuildStartsWithEventAndContainsPatternStep contains(UsagePattern containsPattern) {
194            UsagePatternBuilder.this.containsPattern = containsPattern;
195            return new BuildStartsWithEventAndContainsPatternStep();
196        }
197       
198        /**
199         * <p>
200         * TODO: comment
201         * </p>
202         *
203         * @return
204         */
205        public UsagePattern build() {
206            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent));
207        }
208       
209    }
210   
211    public class BuildStartsWithPatternStep {
212
213        /**
214         * <p>
215         * TODO: comment
216         * </p>
217         *
218         * @param containsEvent
219         * @return
220         */
221        public BuildStartsWithPatternAndContainsEventStep contains(EventTypeFilter containsEvent) {
222            UsagePatternBuilder.this.containsEvent = containsEvent;
223            return new BuildStartsWithPatternAndContainsEventStep();
224        }
225       
226        /**
227         * <p>
228         * TODO: comment
229         * </p>
230         *
231         * @param containedPattern
232         * @return
233         */
234        public BuildStartsWithPatternAndContainsPatternStep contains(UsagePattern containsPattern) {
235            UsagePatternBuilder.this.containsPattern = containsPattern;
236            return new BuildStartsWithPatternAndContainsPatternStep();
237        }
238       
239        /**
240         * <p>
241         * TODO: comment
242         * </p>
243         *
244         * @param textInput
245         * @return
246         */
247        public BuildStartsWithPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
248            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
249            return new BuildStartsWithPatternAndEndsWithEventStep();
250        }
251       
252        /**
253         * <p>
254         * TODO: comment
255         * </p>
256         *
257         * @param endsWithPattern
258         * @return
259         */
260        public BuildStartsAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
261            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
262            return new BuildStartsAndEndsWithPatternStep();
263        }
264       
265        /**
266         * <p>
267         * TODO: comment
268         * </p>
269         *
270         * @return
271         */
272        public UsagePattern build() {
273            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern));
274        }
275       
276    }
277   
278    public class BuildEndsWithEventStep {
279
280        /**
281         * <p>
282         * TODO: comment
283         * </p>
284         *
285         * @return
286         */
287        public UsagePattern build() {
288            return new UsagePattern(concernedNode, new EndsWithEventVisitor(endsWithEvent));
289        }
290       
291    }
292   
293    public class BuildEndsWithPatternStep {
294
295        /**
296         * <p>
297         * TODO: comment
298         * </p>
299         *
300         * @return
301         */
302        public UsagePattern build() {
303            return new UsagePattern(concernedNode, new EndsWithPatternVisitor(endsWithPattern));
304        }
305       
306    }
307   
308    public class BuildContainsEventStep {
309
310        /**
311         * <p>
312         * TODO: comment
313         * </p>
314         *
315         * @param textInput
316         * @return
317         */
318        public BuildContainsAndEndsWithEventStep endsWith(EventTypeFilter endsWithType) {
319            UsagePatternBuilder.this.endsWithEvent = endsWithType;
320            return new BuildContainsAndEndsWithEventStep();
321        }
322       
323        /**
324         * <p>
325         * TODO: comment
326         * </p>
327         *
328         * @return
329         */
330        public UsagePattern build() {
331            return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent));
332        }
333       
334    }
335   
336    public class BuildContainsPatternStep {
337       
338        /**
339         * <p>
340         * TODO: comment
341         * </p>
342         *
343         * @return
344         */
345        public UsagePattern build() {
346            return new UsagePattern(concernedNode, new ContainsPatternVisitor(containsPattern));
347        }
348       
349    }
350   
351    public class BuildStartsAndEndsWithEventStep {
352       
353        /**
354         * <p>
355         * TODO: comment
356         * </p>
357         *
358         * @return
359         */
360        public UsagePattern build() {
361            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent));
362        }
363       
364    }
365   
366    public class BuildStartsWithEventAndEndsWithPattern {
367       
368        /**
369         * <p>
370         * TODO: comment
371         * </p>
372         *
373         * @return
374         */
375        public UsagePattern build() {
376            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithPatternVisitor(endsWithPattern));
377        }
378       
379    }
380   
381    public class BuildStartsWithPatternAndEndsWithEventStep {
382       
383        /**
384         * <p>
385         * TODO: comment
386         * </p>
387         *
388         * @return
389         */
390        public UsagePattern build() {
391            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithEventVisitor(endsWithEvent));
392        }
393       
394    }
395   
396    public class BuildStartsAndEndsWithPatternStep {
397       
398        /**
399         * <p>
400         * TODO: comment
401         * </p>
402         *
403         * @return
404         */
405        public UsagePattern build() {
406            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern));
407        }
408       
409    }
410   
411    public class BuildStartsWithEventAndContainsEventStep {
412       
413        /**
414         * <p>
415         * TODO: comment
416         * </p>
417         *
418         * @param textInput
419         * @return
420         */
421        public BuildStartsAndEndsWithEventAndContainsEventStep endsWith(EventTypeFilter endsWithEvent) {
422            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
423            return new BuildStartsAndEndsWithEventAndContainsEventStep();
424        }
425       
426        /**
427         * <p>
428         * TODO: comment
429         * </p>
430         *
431         * @param endsWithPattern
432         * @return
433         */
434        public BuildStartsWithEventContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
435            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
436            return new BuildStartsWithEventContainsEventAndEndsWithPatternStep();
437        }
438       
439        /**
440         * <p>
441         * TODO: comment
442         * </p>
443         *
444         * @return
445         */
446        public UsagePattern build() {
447            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent));
448        }
449       
450    }
451   
452    public class BuildStartsWithPatternAndContainsPatternStep {
453       
454        /**
455         * <p>
456         * TODO: comment
457         * </p>
458         *
459         * @param textInput
460         * @return
461         */
462        public BuildStartsContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
463            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
464            return new BuildStartsContainsPatternAndEndsWithEventStep();
465        }
466       
467        /**
468         * <p>
469         * TODO: comment
470         * </p>
471         *
472         * @param endsWithPattern
473         * @return
474         */
475        public BuildStartsAndEndsWithPatternAndContainsPatternStep endsWith(UsagePattern endsWithPattern) {
476            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
477            return new BuildStartsAndEndsWithPatternAndContainsPatternStep();
478        }
479       
480        /**
481         * <p>
482         * TODO: comment
483         * </p>
484         *
485         * @return
486         */
487        public UsagePattern build() {
488            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern));
489        }
490       
491    }
492   
493    public class BuildStartsWithEventAndContainsPatternStep {
494       
495        /**
496         * <p>
497         * TODO: comment
498         * </p>
499         *
500         * @param textInput
501         * @return
502         */
503        public BuildStartsWithEventContainsPatternAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
504            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
505            return new BuildStartsWithEventContainsPatternAndEndsWithEventStep();
506        }
507       
508        /**
509         * <p>
510         * TODO: comment
511         * </p>
512         *
513         * @param endsWithPattern
514         * @return
515         */
516        public BuildStartsWithEventContainsPatternAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
517            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
518            return new BuildStartsWithEventContainsPatternAndEndsWithPatternStep();
519        }
520       
521        /**
522         * <p>
523         * TODO: comment
524         * </p>
525         *
526         * @return
527         */
528        public UsagePattern build() {
529            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern));
530        }
531       
532    }
533   
534    public class BuildStartsWithPatternAndContainsEventStep {
535       
536        /**
537         * <p>
538         * TODO: comment
539         * </p>
540         *
541         * @param textInput
542         * @return
543         */
544        public BuildStartsWithPatternContainsEventAndEndsWithEventStep endsWith(EventTypeFilter endsWithEvent) {
545            UsagePatternBuilder.this.endsWithEvent = endsWithEvent;
546            return new BuildStartsWithPatternContainsEventAndEndsWithEventStep();
547        }
548       
549        /**
550         * <p>
551         * TODO: comment
552         * </p>
553         *
554         * @param endsWithPattern
555         * @return
556         */
557        public BuildStartsWithPatternContainsEventAndEndsWithPatternStep endsWith(UsagePattern endsWithPattern) {
558            UsagePatternBuilder.this.endsWithPattern = endsWithPattern;
559            return new BuildStartsWithPatternContainsEventAndEndsWithPatternStep();
560        }
561       
562        /**
563         * <p>
564         * TODO: comment
565         * </p>
566         *
567         * @return
568         */
569        public UsagePattern build() {
570            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent));
571        }
572       
573    }
574   
575    public class BuildStartsAndEndsWithEventAndContainsEventStep {
576       
577        /**
578         * <p>
579         * TODO: comment
580         * </p>
581         *
582         * @return
583         */
584        public UsagePattern build() {
585            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new EndsWithEventVisitor(endsWithEvent), new ContainsEventVisitor(containsEvent));
586        }
587       
588    }
589   
590    public class BuildStartsContainsPatternAndEndsWithEventStep {
591       
592        /**
593         * <p>
594         * TODO: comment
595         * </p>
596         *
597         * @return
598         */
599        public UsagePattern build() {
600            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
601        }
602       
603    }
604   
605    public class BuildStartsAndEndsWithPatternAndContainsPatternStep {
606       
607        /**
608         * <p>
609         * TODO: comment
610         * </p>
611         *
612         * @return
613         */
614        public UsagePattern build() {
615            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new EndsWithPatternVisitor(endsWithPattern), new ContainsPatternVisitor(containsPattern));
616        }
617       
618    }
619   
620    public class BuildStartsWithEventContainsEventAndEndsWithPatternStep {
621       
622        /**
623         * <p>
624         * TODO: comment
625         * </p>
626         *
627         * @return
628         */
629        public UsagePattern build() {
630            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
631        }
632       
633    }
634   
635    public class BuildStartsWithEventContainsPatternAndEndsWithEventStep {
636       
637        /**
638         * <p>
639         * TODO: comment
640         * </p>
641         *
642         * @return
643         */
644        public UsagePattern build() {
645            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithEventVisitor(endsWithEvent));
646        }
647       
648    }
649   
650    public class BuildStartsWithEventContainsPatternAndEndsWithPatternStep {
651       
652        /**
653         * <p>
654         * TODO: comment
655         * </p>
656         *
657         * @return
658         */
659        public UsagePattern build() {
660            return new UsagePattern(concernedNode, new StartsWithEventVisitor(startsWithEvent), new ContainsPatternVisitor(containsPattern), new EndsWithPatternVisitor(endsWithPattern));
661        }
662       
663    }
664   
665    public class BuildStartsWithPatternContainsEventAndEndsWithEventStep {
666       
667        /**
668         * <p>
669         * TODO: comment
670         * </p>
671         *
672         * @return
673         */
674        public UsagePattern build() {
675            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
676        }
677       
678    }
679   
680    public class BuildStartsWithPatternContainsEventAndEndsWithPatternStep {
681       
682        /**
683         * <p>
684         * TODO: comment
685         * </p>
686         *
687         * @return
688         */
689        public UsagePattern build() {
690            return new UsagePattern(concernedNode, new StartsWithPatternVisitor(startsWithPattern), new ContainsEventVisitor(containsEvent), new EndsWithPatternVisitor(endsWithPattern));
691        }
692       
693    }
694   
695    public class BuildContainsAndEndsWithEventStep {
696       
697        /**
698         * <p>
699         * TODO: comment
700         * </p>
701         *
702         * @return
703         */
704        public UsagePattern build() {
705            return new UsagePattern(concernedNode, new ContainsEventVisitor(containsEvent), new EndsWithEventVisitor(endsWithEvent));
706        }
707       
708    }
709
710}
Note: See TracBrowser for help on using the repository browser.