Source Code Cross Referenced for AbstractCrosscut.java in  » Byte-Code » PROSE » ch » ethz » prose » crosscut » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Byte Code » PROSE » ch.ethz.prose.crosscut 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


001:        //
002:        //  This file is part of the prose package.
003:        //
004:        //  The contents of this file are subject to the Mozilla Public License
005:        //  Version 1.1 (the "License"); you may not use this file except in
006:        //  compliance with the License. You may obtain a copy of the License at
007:        //  http://www.mozilla.org/MPL/
008:        //
009:        //  Software distributed under the License is distributed on an "AS IS" basis,
010:        //  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
011:        //  for the specific language governing rights and limitations under the
012:        //  License.
013:        //
014:        //  The Original Code is prose.
015:        //
016:        //  The Initial Developer of the Original Code is Andrei Popovici. Portions
017:        //  created by Andrei Popovici are Copyright (C) 2002 Andrei Popovici.
018:        //  All Rights Reserved.
019:        //
020:        //  Contributor(s):
021:        // $Id: AbstractCrosscut.java,v 1.3 2005/06/25 17:16:41 anicoara Exp $
022:        // =====================================================================
023:        //
024:        // (history at end)
025:        //
026:
027:        package ch.ethz.prose.crosscut;
028:
029:        import java.lang.reflect.InvocationTargetException;
030:        import java.util.Iterator;
031:
032:        import ch.ethz.jvmai.ExceptionJoinPoint;
033:        import ch.ethz.jvmai.ExceptionCatchJoinPoint;
034:        import ch.ethz.jvmai.FieldAccessJoinPoint;
035:        import ch.ethz.jvmai.FieldModificationJoinPoint;
036:        import ch.ethz.jvmai.JoinPoint;
037:        import ch.ethz.jvmai.MethodEntryJoinPoint;
038:        import ch.ethz.jvmai.MethodExitJoinPoint;
039:        import ch.ethz.jvmai.ConstructorJoinPoint;
040:        import ch.ethz.prose.ProseSystem;
041:        import ch.ethz.prose.Aspect;
042:        import ch.ethz.prose.filter.PointCutter;
043:        import ch.ethz.prose.filter.PointFilter;
044:        import ch.ethz.prose.engine.JoinPointRequest;
045:        import ch.ethz.prose.engine.JoinPointManager;
046:
047:        /**
048:         *
049:         * Interface AbstractCrosscut is a Crosscut implementation together with
050:         * a  filtering mechanism for
051:         * both join-point requests and join-point events. Every AbstractCrosscut
052:         * owns a <code>PointFilter</code>. A specializer is a
053:         * strategy-object used for filtering event requests.
054:         * <p>
055:         * A Crosscut is used to generate a crosscut request, that is,
056:         * a collection of join-point requests(Method <code>createRequest</code>).
057:         * Upon the first usage of
058:         * a crosscut, the crosscut selects a number of classes in the current
059:         * virtual machine or maybe all (default), and then generates for every potential
060:         * point inside these classes (e.g. for all method entries, exits, or field
061:         * accesses) a separate join point request. Before returning these requests
062:         * to the user of the crosscut, it applies the filter provided by its
063:         * specializer to every one of them. Only the ones which passed are
064:         * returned in the crosscut.
065:         * <p>
066:         * For each event it receives, the abstract crosscut uses the
067:         * specializer as a filter. If the specializer allows the
068:         * action corresponding to this event, <code>joinPointAction</code>
069:         * is called with the current event as a  parameter. If the specializer
070:         * disagrees with the current event, no action is performed.
071:         *
072:         * <h4> How to extend <code>AbstractCrosscut</code></h4>
073:         * Every subclass of crosscut will have to provide implementations for
074:         * <code>doCreateRequest(Class)</code>, <code>joinPointAction</code> and
075:         * possibly for <code>potentialCrosscutClasses</code>. Implementations
076:         * of these methods have to use the <code>getRequestFactory</code> to retrieve
077:         * the factory for creating the necessary <code>JoinPointRequest</code>
078:         * objects.
079:         *
080:         * @version	$Revision: 1.3 $
081:         * @author	Andrei Popovici
082:         * @author  	Angela Nicoara
083:         */
084:        public abstract class AbstractCrosscut extends Crosscut {
085:
086:            private Aspect theOwner = null;
087:            private PointFilter theSpecializer = null;
088:            private CrosscutGroup transactionGrp = new CrosscutGroup();
089:            private static ThreadLocal threadLocalJoinPoint = new ThreadLocal();
090:
091:            /** This is the info interface of the current system.
092:             *  The implementation must ensure that these interfaces are
093:             * initialized when <code>joinPointReached</code> is called.
094:             *
095:             */
096:            protected transient JoinPointManager requestFactory = null;
097:
098:            /** Upon insertion, the a default (abstract) crosscuts
099:             * tries to figure out where it is running. It then
100:             * initializes the infoInterface and aspectInterface
101:             * variables.
102:             *
103:             * @param beforeInsertion true if the crosscut is not yet inserted.
104:             */
105:            public void insertionAction(boolean beforeInsertion) {
106:                // BIG FIXME: how do I insert a thing into the test aspect manager?
107:                if (requestFactory == null)
108:                    requestFactory = ProseSystem.getAspectManager()
109:                            .getJoinPointManager();
110:            }
111:
112:            public void withdrawalAction(boolean beforeInsertion) {
113:                // void
114:            }
115:
116:            /** Set the owner of this crosscut. This can be done only if the
117:             * current crosscut does not have an owner.
118:             *
119:             */
120:            public void setOwner(Aspect ext) throws IllegalStateException {
121:                if (theOwner == null)
122:                    theOwner = ext;
123:                else
124:                    throw new IllegalStateException(
125:                            "Cannot change ownership of aspects");
126:
127:            }
128:
129:            public Aspect getOwner() {
130:                return theOwner;
131:            }
132:
133:            public int getPriority() {
134:                if (getOwner() == null)
135:                    throw new IllegalStateException(
136:                            "A crosscut cannot live outside of an aspect");
137:
138:                return getOwner().getPriority();
139:            }
140:
141:            /**
142:             * Return an array of classes which will be considered for
143:             *  crosscutting when this crosscut is used to genereate
144:             *  a crosscut request. A crosscut will implement this method
145:             *  if and only if the number of classes it crosscuts is limited.
146:             * <p>
147:             * The default implementation is to return <em>all loaded classes</em>
148:             * of the current VM, which means that the default is to crosscut
149:             * whatever is loaded in the VM (including abstract classes and
150:             * interfaces! (?)).
151:             */
152:            protected synchronized Class[] potentialCrosscutClasses() {
153:                return (Class[]) requestFactory.getLoadedClasses().toArray(
154:                        new Class[] {});
155:            }
156:
157:            /** Override this method if you want to filter
158:             * the clases to be crosscut at runtime. The potential crosscut
159:             * classes denotes the initial number of classes to be
160:             * cutt across. Classes may be loaded later on, and this
161:             * method decides whether they should be searched for
162:             * join points or not.
163:             */
164:            protected boolean isPotentialCrosscutClass(Class c) {
165:                return true;
166:            }
167:
168:            /**
169:             * This method determines the join-points of the specified
170:             * class (<code>c</code>).  To generate join-point requests,
171:             * it uses the <code>doCreateRequest</code> templated method.
172:             * This method guarantees that the resulting requests:
173:             * <ol>
174:             * <li> belong to classes that pass the predicate
175:             * <code>isPotentialCrosscutClass</code>
176:             * <li> are allowes by this crosscuts specializer (if any)
177:             * </ol>
178:             * <p>
179:             * This method will also be used every time a new class is
180:             * loaded in the current VM in order to determine
181:             * the new requests.
182:             */
183:            public final CrosscutRequest createRequest(Class c) {
184:                // make shure we can access the aspect interface
185:                requestFactory = ProseSystem.getAspectManager()
186:                        .getJoinPointManager();
187:
188:                CrosscutRequest result = new CrosscutRequest();
189:
190:                // there are two optimizations that follow:
191:                // 1 (optimization)
192:                // try to check whether the user wants this class to be used
193:                if (!isPotentialCrosscutClass(c)) {
194:                    return result;
195:                }
196:
197:                /// 2 (optimization) a seccond optimization is about speeding the process of crosscut
198:                /// creation. A default crosscut will get all classses in the VM,
199:                /// create,say, for each field a request and then filter out of the
200:                /// 15000 requests the two it is interested in. To speed a little bit
201:                /// the process, we create a faked Joinpointrequest, and check
202:                /// whether the existing specializer will accept this class.
203:                /// BIG FIXME: WITH THE NEW WAY OF DEALING WITH THINGS,
204:                /// WE SHOULD BE MORE ELABORATE HERE. The problem is
205:                /// that the fakedRequest should be categorized in
206:                /// a certain area..
207:                //      synchronized(fakedRequest)
208:                //{
209:                //fakedRequest.setTargetClass(c);
210:                //if (theSpecializer != null &&g
211:                //!theSpecializer.isSpecialRequest(fakedRequest))
212:                //return result;
213:                //}
214:
215:                // 3.  create a request
216:                CrosscutRequest cr = doCreateRequest(c);
217:
218:                if (getSpecializer() == null)
219:                    return cr;
220:
221:                Iterator i = cr.iterator();
222:                while (i.hasNext()) {
223:                    JoinPointRequest jpr = (JoinPointRequest) i.next();
224:                    if (getSpecializer().isSpecialRequest(jpr))
225:                        result.add(jpr);
226:                }
227:
228:                return result;
229:
230:            }
231:
232:            /**
233:             * This method has to be implemented by subclasses. It basically
234:             * represents the initial generation mechanisms for Join point
235:             * requests. It should return indiscriminatly a lot of join-points
236:             * for every potential join-point in the byte-code of the specified
237:             * class.
238:             */
239:            protected abstract CrosscutRequest doCreateRequest(Class c);
240:
241:            /** This method has to be implemented by concrete crosscut implementation.
242:             * It returns the thread-local <code>JoinPointEvent</code> object. It
243:             * can be called just below the control flow of a joinPointAction.
244:             *
245:             * @throws IllegalStateException if this mehtod is invoked from outside
246:             * a join-point notification.
247:             */
248:            protected JoinPoint this JoinPoint() throws IllegalStateException {
249:                return (JoinPoint) threadLocalJoinPoint.get();
250:            }
251:
252:            /**
253:             * This method is the mechanism used by an extension for creating
254:             * a crosscut Request. It uses the <code>createRequest(Class c)</code>
255:             * method to build up a crosscut for the entire local VM.
256:             * It has the following functionality:
257:             * for each potential crosscut class (as returned by
258:             * <code>potentialCrosscutClasses</code>),
259:             * the method <code>createRequest(Class c)</code> is applied.
260:             * The result corresponds to the union of all requests returned by
261:             * <code>createRequest(Class c)</code>.
262:             */
263:            public final CrosscutRequest createRequest() {
264:                // make shure we can access the aspect interface
265:                requestFactory = ProseSystem.getAspectManager()
266:                        .getJoinPointManager();
267:
268:                //1. create the request
269:                //FIXME: I don't like using the constructor!
270:                CrosscutRequest result = new CrosscutRequest();
271:
272:                //2.  get the potential crosscut classes
273:                Class[] theClasses = potentialCrosscutClasses();
274:                if (theClasses == null)
275:                    return result;
276:
277:                //System.out.println("AbstractCrosscut - createRequest -> BEGINCLASSES");
278:                //System.out.println(java.util.Arrays.asList(theClasses));
279:                //System.out.println("AbstractCrosscut - createRequest -> ENDCLASSES");
280:
281:                //3. the resulting crosscut request is the
282:                // union for crosscut requests for all classes.
283:                for (int i = 0; i < theClasses.length; i++)
284:                    result.addAll(createRequest(theClasses[i]));
285:                return result;
286:            }
287:
288:            /**
289:             * This method performs the actions upon receiving a JoinPointEvent.
290:             * If this crosscut has a specializer, and the current event is
291:             * accepted by the specializer, then
292:             * <code>joinPointAction</code> is invoked.
293:             * If it has no specializer, <code>joinPointAction</code>
294:             * is invoked by default.
295:             *
296:             * @param jp the current join point
297:             */
298:            public void joinPointReached(MethodEntryJoinPoint jp)
299:                    throws Exception {
300:
301:                if (transactionGrp.executeAdvice
302:                        && ((getSpecializer() == null) || getSpecializer()
303:                                .isSpecialEvent(jp))) {
304:                    threadLocalJoinPoint.set(jp);
305:                    joinPointAction(jp);
306:                }
307:            }
308:
309:            /**
310:             * This method performs the actions upon receiving a JoinPointEvent.
311:             * If this crosscut has a specializer, and the current event is
312:             * accepted by the specializer, then
313:             * <code>joinPointAction</code> is invoked.
314:             * If it has no specializer, <code>joinPointAction</code>
315:             * is invoked by default.
316:             *
317:             * @param jp the current join point
318:             */
319:            public void joinPointReached(ConstructorJoinPoint jp)
320:                    throws Exception {
321:                if (transactionGrp.executeAdvice
322:                        && ((getSpecializer() == null) || getSpecializer()
323:                                .isSpecialEvent(jp))) {
324:                    threadLocalJoinPoint.set(jp);
325:                    joinPointAction(jp);
326:                }
327:            }
328:
329:            protected PointCutter NOT(PointCutter cs) {
330:                return new ch.ethz.prose.filter.NegatingPointCutter(cs);
331:            }
332:
333:            /**
334:             * This method performs the actions upon receiving a JoinPointEvent.
335:             * If this crosscut has a specializer, and the current event is
336:             * accepted by the specializer, then
337:             * <code>joinPointAction</code> is invoked.
338:             * If it has no specializer, <code>joinPointAction</code>
339:             * is invoked by default.
340:             *
341:             * @param jp the current join point
342:             */
343:            public void joinPointReached(MethodExitJoinPoint jp)
344:                    throws Exception {
345:                if (transactionGrp.executeAdvice
346:                        && ((getSpecializer() == null) || getSpecializer()
347:                                .isSpecialEvent(jp))) {
348:                    threadLocalJoinPoint.set(jp);
349:                    joinPointAction(jp);
350:                }
351:            }
352:
353:            /**
354:             * This method performs the actions upon receiving a JoinPointEvent.
355:             * If this crosscut has a specializer, and the curren\t event is
356:             * accepted by the specializer, then
357:             * <code>joinPointAction</code> is invoked.
358:             * If it has no specializer, <code>joinPointAction</code>
359:             * is invoked by default.
360:             *
361:             * @param jp the current join point
362:             */
363:            public void joinPointReached(FieldAccessJoinPoint jp)
364:                    throws Exception {
365:                if (transactionGrp.executeAdvice
366:                        && ((getSpecializer() == null) || getSpecializer()
367:                                .isSpecialEvent(jp))) {
368:                    threadLocalJoinPoint.set(jp);
369:                    joinPointAction(jp);
370:                }
371:            }
372:
373:            /**
374:             * This method performs the actions upon receiving a JoinPointEvent.
375:             * If this crosscut has a specializer, and the current event is
376:             * accepted by the specializer, then
377:             * <code>joinPointAction</code> is invoked.
378:             * If it has no specializer, <code>joinPointAction</code>
379:             * is invoked by default.
380:             *
381:             * @param jp the current join point
382:             */
383:            public void joinPointReached(FieldModificationJoinPoint jp)
384:                    throws Exception {
385:                if (transactionGrp.executeAdvice
386:                        && ((getSpecializer() == null) || getSpecializer()
387:                                .isSpecialEvent(jp))) {
388:                    threadLocalJoinPoint.set(jp);
389:                    joinPointAction(jp);
390:                }
391:            }
392:
393:            /**
394:             * This method performs the actions upon receiving a JoinPointEvent.
395:             * If this crosscut has a specializer, and the current event is
396:             * accepted by the specializer, then
397:             * <code>joinPointAction</code> is invoked.
398:             * If it has no specializer, <code>joinPointAction</code>
399:             * is invoked by default.
400:             *
401:             * @param jp the current join point<
402:             */
403:            public void joinPointReached(ExceptionJoinPoint jp)
404:                    throws Exception {
405:                if (transactionGrp.executeAdvice
406:                        && ((getSpecializer() == null) || getSpecializer()
407:                                .isSpecialEvent(jp))) {
408:                    threadLocalJoinPoint.set(jp);
409:                    joinPointAction(jp);
410:                }
411:            }
412:
413:            /**
414:             * This method performs the actions upon receiving a JoinPointEvent.
415:             * If this crosscut has a specializer, and the current event is
416:             * accepted by the specializer, then
417:             * <code>joinPointAction</code> is invoked.
418:             * If it has no specializer, <code>joinPointAction</code>
419:             * is invoked by default.
420:             *
421:             * @param jp the current join point
422:             */
423:            public void joinPointReached(ExceptionCatchJoinPoint jp)
424:                    throws Exception {
425:                if (transactionGrp.executeAdvice
426:                        && ((getSpecializer() == null) || getSpecializer()
427:                                .isSpecialEvent(jp))) {
428:                    threadLocalJoinPoint.set(jp);
429:                    joinPointAction(jp);
430:                }
431:            }
432:
433:            /**
434:             * This method should be implemented by subclasses; this method is
435:             * a template method. This method should perform the action corresponding
436:             * to the receipt of events <code>e</code>.
437:             */
438:            protected void joinPointAction(FieldModificationJoinPoint e)
439:                    throws InvocationTargetException, IllegalAccessException {
440:                throw new Error(
441:                        "Should not be reached; it should be overriden in subclasses");
442:            }
443:
444:            /**
445:             * This method should be implemented by subclasses; this method is
446:             * a template method. This method should perform the action corresponding
447:             * to the receipt of events <code>e</code>.
448:             */
449:            protected void joinPointAction(FieldAccessJoinPoint e)
450:                    throws InvocationTargetException, IllegalAccessException {
451:                throw new Error(
452:                        "Should not be reached. it should be overriden in subclasses");
453:            }
454:
455:            /**
456:             * This method should be implemented by subclasses; this method is
457:             * a template method. This method should perform the action corresponding
458:             * to the receipt of events <code>e</code>.
459:             */
460:            protected void joinPointAction(MethodEntryJoinPoint e)
461:                    throws InvocationTargetException, IllegalAccessException {
462:                throw new Error(
463:                        "Should not be reached.it should be overriden in subclasses");
464:            }
465:
466:            /**
467:             * This method should be implemented by subclasses; this method is
468:             * a template method. This method should perform the action corresponding
469:             * to the receipt of events <code>e</code>.
470:             */
471:            protected void joinPointAction(ConstructorJoinPoint e)
472:                    throws InvocationTargetException, IllegalAccessException {
473:                throw new Error(
474:                        "Should not be reached.it should be overriden in subclasses");
475:            }
476:
477:            /**
478:             * This method should be implemented by subclasses; this method is
479:             * a template method. This method should perform the action corresponding
480:             * to the receipt of events <code>e</code>.
481:             */
482:            protected void joinPointAction(MethodExitJoinPoint e)
483:                    throws InvocationTargetException, IllegalAccessException {
484:                throw new Error(
485:                        "Should not be reached.it should be overriden in subclasses");
486:            }
487:
488:            /**
489:             * This method should be implemented by subclasses; this method is
490:             * a template method. This method should perform the action corresponding
491:             * to the receipt of events <code>e</code>.
492:             */
493:            protected void joinPointAction(ExceptionJoinPoint e)
494:                    throws InvocationTargetException, IllegalAccessException {
495:                throw new Error(
496:                        "Should not be reached.it should be overriden in subclasses");
497:            }
498:
499:            /**
500:             * This method should be implemented by subclasses; this method is
501:             * a template method. This method should perform the action corresponding
502:             * to the receipt of events <code>e</code>.
503:             */
504:            protected void joinPointAction(ExceptionCatchJoinPoint e)
505:                    throws InvocationTargetException, IllegalAccessException {
506:                throw new Error(
507:                        "Should not be reached.it should be overriden in subclasses");
508:            }
509:
510:            /**
511:             * Return the current specializer.
512:             *
513:             * @return the current specializer
514:             */
515:            public PointFilter getSpecializer() {
516:                if (theSpecializer == null)
517:                    theSpecializer = pointCutter();
518:
519:                return theSpecializer;
520:            }
521:
522:            protected abstract PointCutter pointCutter();
523:
524:            /**
525:             * Associated this crosscut to the group <code>grp</code>.
526:             *
527:             */
528:            public void associateToGroup(CrosscutGroup grp)
529:                    throws IllegalArgumentException {
530:                transactionGrp = grp;
531:            }
532:
533:            /**
534:             *
535:             */
536:            public String toString() {
537:                return "Crosscut '" + getClass().getName()
538:                        + "' specialized with [" + getSpecializer() + "]";
539:            }
540:        }
541:
542:        //======================================================================
543:        //
544:        // $Log: AbstractCrosscut.java,v $
545:        // Revision 1.3  2005/06/25 17:16:41  anicoara
546:        // Clean up the code
547:        //
548:        // Revision 1.2  2004/05/12 09:41:55  anicoara
549:        // Remove the README.RVM file
550:        //
551:        // Revision 1.1.1.1  2003/07/02 15:30:51  apopovic
552:        // Imported from ETH Zurich
553:        //
554:        // Revision 1.3  2003/07/02 12:42:51  anicoara
555:        // Added CatchJoinPoint Functionality (Requests, Join-Points, Filters, CatchCuts, Tests)
556:        //
557:        // Revision 1.2  2003/06/25 09:04:10  popovici
558:        // Bug fix in synchronizing class producers and consumers; FIXME comment added to AbstractCrosscut
559:        //
560:        // Revision 1.1  2003/05/05 13:58:08  popovici
561:        // renaming from runes to prose
562:        //
563:        // Revision 1.28  2003/04/29 12:41:05  popovici
564:        // Feature added:
565:        // - the 'setPriority' in class insertable allows now Aspects and Crosscuts to have a priority.
566:        //   Notitification is done from low int priorities to high int priorities.
567:        // - the 'setAspectID' introduced to replace constuctor; used to be cumberstone for subclasses
568:        //
569:        // Revision 1.27  2003/04/27 13:08:57  popovici
570:        // Specializers renamed to PointCutter
571:        //
572:        // Revision 1.26  2003/04/26 18:51:32  popovici
573:        // 1 Bug fix which lead to a refactoring step:
574:        //    1. the bug: 'JoinPointRequests' used to write to a static list, which survived a startup/teardown;
575:        //                now this list belongs to the JoinPointManager;
576:        //    2. the refactoring: the JoinPointManager now creates (and shares state) with join-points.
577:        //
578:        // Revision 1.25  2003/04/17 15:15:19  popovici
579:        // Extension->Aspect renaming
580:        //
581:        // Revision 1.24  2003/04/17 13:54:31  popovici
582:        // Refactorization of 'ExecutionS' into 'Within' and 'Executions'.
583:        // Method names refer now to 'types'
584:        //
585:        // Revision 1.23  2003/04/17 12:49:24  popovici
586:        // Refactoring of the crosscut package
587:        //  ExceptionCut renamed to ThrowCut
588:        //  McutSignature is now SignaturePattern
589:        //
590:        // Revision 1.22  2003/04/17 08:47:16  popovici
591:        // Important functionality additions
592:        //  - Cflow specializers
593:        //  - Restructuring of the MethodCut, SetCut, ThrowCut, and GetCut (they are much smaller)
594:        //  - Transactional capabilities
595:        //  - Total refactoring of Specializer evaluation, which permits fine-grained distinction
596:        //    between static and dynamic specializers.
597:        //  - Functionality pulled up in abstract classes
598:        //  - Uniformization of advice methods patterns and names
599:        //
600:        // Revision 1.21  2003/03/05 13:13:57  popovici
601:        // MethodCut unobfusscated by translating inner
602:        // classes for method advice and method signatures
603:        // to top level classes.
604:        //
605:        // Revision 1.20  2003/03/04 18:36:35  popovici
606:        // Organization of imprts
607:        //
608:        // Revision 1.19  2003/03/04 11:27:17  popovici
609:        // Important refactorization step (march):
610:        // - removal of 'JoinPointEvents'; JoinPoints now have the same function as events
611:        // - reimplementation of the JVMAIDebuggerAspectInterface (better performance, coding conventions, removal of ProseVM
612:        //   structures
613:        //
614:        // Revision 1.18  2003/02/11 14:28:45  popovici
615:        // Serialization Problems solved; for MethodCut; Used to deserialize
616:        // with null values for 'UserDefinedMCSignature'. Insertion caused problems
617:        //
618:        // Revision 1.17  2002/11/26 17:15:07  pschoch
619:        // RootComponent now added (replaces RootComponent now added (replaces old ProseSystem)
620:        // ProseSystem now owns and starts the Aspect interface.
621:        // ProseSystem now containes  a 'test' AspectManager
622:        // AspectManager now owns the JoinPointManager.
623:        // ExtensionManger can be 'connected' to the JVM, or disconnected. The
624:        // JoinPointManager of a connected Ext.Mgr enables joinpoints; the
625:        // JoinPointManger of a disconnected Ext.Mgr never enables join-points
626:        // Documentation updated accordingly.
627:        //
628:        // Revision 1.16  2002/10/31 18:26:50  pschoch
629:        // Capability of crosscutting Exceptions added to prose.
630:        //
631:        // Revision 1.15  2002/10/25 07:42:33  popovici
632:        // Undo Chnages Phillippe
633:        //
634:        // Revision 1.13  2002/06/07 15:30:50  popovici
635:        // Documentation updates of FunctionalCrosscut/ClasseS refactorings
636:        //
637:        // Revision 1.12  2002/06/07 07:47:41  popovici
638:        // Feature change: MemberS.doIsSpecialRequest signature changed to include a JoinPointRequest.
639:        // This fixed a bug in MethodS.BEFORE1/MethodS.after, which had no way to distinguish between entries and exits
640:        //
641:        // Revision 1.11  2002/06/05 09:27:58  popovici
642:        // thisJoinPoint() introduced in Abstract Crosscut and subclasses;
643:        //
644:        // Revision 1.10  2002/06/04 12:36:10  popovici
645:        // MethodCut occurences replaced with MethodCut
646:        //
647:        // Revision 1.9  2002/06/04 11:52:32  popovici
648:        // Small refactorization: createRequest() now uses createRequest(Class);
649:        //
650:        // Revision 1.8  2002/05/28 15:57:36  popovici
651:        // NOT function added
652:        //
653:        // Revision 1.7  2002/05/07 10:46:51  popovici
654:        // Reorganization of the Specializer package. All specializer related classes
655:        // moved to ch.ethz.inf.crossucut.spec; Classes ORSpecializer, ANDspecializer and NOTspecializer is
656:        // introduced, the static analysis of filtering simplified, because now specializers
657:        // contain a field 'filterType' which is propagated to the root of composite specializers. junit packages updated accordingly
658:        //
659:        // Revision 1.6  2002/03/28 13:48:40  popovici
660:        // Mozilla-ified
661:        //
662:        // Revision 1.5  2002/03/12 09:49:32  popovici
663:        // Join Point listener now abstract class (performance reasons)
664:        //
665:        // Revision 1.4  2002/03/06 13:48:37  popovici
666:        // joinPointAction now in 4 flavours, depending on the join point type
667:        //
668:        // Revision 1.3  2002/02/21 12:39:19  popovici
669:        // Crosscut efficiency issues:
670:        //   - joinPointAction dispatch based on static optimization
671:        //      (->doesEventSpecialization, 'setSpecializer' modified)
672:        //      (->calculation of 'adviceMethodOptimization', in Func.Crossc)
673:        //   - joinPointAction now uses JoinPoints (not Events)
674:        //   - JoinPointListeners (including crosscuts) now use joinPointReached(XXXJoinPoint) to avoid casting
675:        // Crosscut architectural issues:
676:        //   - AbstractCrosscut now insertable.
677:        //   - AbstractCrosscuts owns referecnces to JVMAI
678:        //
679:        // Revision 1.2  2002/02/05 09:45:54  smarkwal
680:        // JVMDI-specific code replaced by JVMAI. Prose-implementation classes and reflection package removed.
681:        //
682:        // Revision 1.1.1.1  2001/11/29 18:13:16  popovici
683:        // Sources from runes
684:        //
685:        // Revision 1.1.2.12  2001/11/21 11:56:24  popovici
686:        //
687:        // -The sun.tools.agent and ch.ethz.inf.util.JVMDIUtil functionality
688:        // replaced with the iks.jvmdi package. References to this old
689:        // functionality replaced throughout the code.
690:        // -Partial reimplementation of the ch.ethz.inf.iks.runes classes,
691:        // part of their functionality moved to the ch.ethz.prose.reflect
692:        // abstract classes. New classes and functionality added to the
693:        // ch.ethz.prose.reflect package, partially to reflect the
694:        // more stable features taken from the iks.runes packages, partially
695:        // to reflect the structure of the VM (constant pool, etc). Functionality in
696:        // ch.ethz.prose.crosscut and the junit classes adapted to use the
697:        // new form of the ch.ethz.prose.reflect package
698:        //
699:        // Revision 1.1.2.11  2001/09/24 16:29:49  popovici
700:        // demo errors removed
701:        //
702:        // Revision 1.1.2.10  2001/07/15 13:07:26  popovici
703:        // Method 'isPotentialCrosscutClass' added. Optimizations of crosscut
704:        // generation added.
705:        //
706:        // Revision 1.1.2.9  2001/06/08 14:05:24  popovici
707:        // Bug fix: automatical update of crosscuts upon class load used to
708:        // ignore the type correctness of the crosscut contract. Fixed.
709:        //
710:        // Revision 1.1.2.8  2001/03/06 08:45:00  mrmuller
711:        // corrected spelling in javadoc
712:        //
713:        // Revision 1.1.2.7  2001/02/21 13:28:58  popovici
714:        // Method 'toString' added for subclasses.
715:        //
716:        // Revision 1.1.2.6  2001/02/13 15:16:30  popovici
717:        // JoinPointRequestFactory now transient
718:        //
719:        // Revision 1.1.2.5  2000/11/28 17:02:07  groos
720:        // minor documentation updates.
721:        //
722:        // Revision 1.1.2.4  2000/11/15 15:14:47  popovici
723:        // joinPointAction throws now IllegalAccessException too
724:        //
725:        // Revision 1.1.2.3  2000/10/30 17:28:49  groos
726:        // documentation updates
727:        //
728:        // Revision 1.1.2.2  2000/10/25 09:07:02  popovici
729:        // Bug fixed in 'joinPointReached' : in the absence of specializer, events
730:        // were not sent to 'joinPointAction'. Documentation updated. Method 'toString'
731:        // added.
732:        //
733:        // Revision 1.1.2.1  2000/10/23 18:28:09  popovici
734:        // Moved from ch.ethz.prose to ch.ethz.prose.crosscut and renamed to
735:        // AbstractCrosscut
736:        //
737:        // Revision 1.1.2.3  2000/10/18 19:21:48  popovici
738:        // Uses now 'VirtualMachine' as reflective info factory
739:        //
740:        // Revision 1.1.2.2  2000/10/18 12:52:21  popovici
741:        // Documentation detailed
742:        //
743:        // Revision 1.1.2.1  2000/10/16 18:26:18  popovici
744:        // Documentation Added. Semantic of 'potentialCrosscutClasses' changed
745:        // (now returns all loaded classes by default). Method 'doCreateRequest'
746:        // added.
747:        //
748:        // Revision 1.1  2000/10/16 11:53:22  popovici
749:        // Initial Revision
750:        //
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.