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: //
|