001 /***************************************************************************** 002 * Copyright (c) PicoContainer Organization. All rights reserved. * 003 * ------------------------------------------------------------------------- * 004 * The software in this package is published under the terms of the BSD * 005 * style license a copy of which has been included with this distribution in * 006 * the LICENSE.txt file. * 007 * * 008 * Idea by Rachel Davies, Original code by various * 009 *****************************************************************************/ 010 package org.nanocontainer.aop.dynaop; 011 012 import dynaop.Pointcuts; 013 import org.apache.oro.text.regex.MalformedPatternException; 014 import org.nanocontainer.aop.ClassPointcut; 015 import org.nanocontainer.aop.MalformedRegularExpressionException; 016 import org.nanocontainer.aop.MethodPointcut; 017 import org.nanocontainer.aop.defaults.AbstractPointcutsFactory; 018 019 import java.lang.reflect.Method; 020 021 /** 022 * Implements the <code>org.nanocontainer.aop.PointcutsFactory</code> 023 * interface using dynaop. 024 * 025 * @author Stephen Molitor 026 * @version $Revision: 3144 $ 027 */ 028 public class DynaopPointcutsFactory extends AbstractPointcutsFactory { 029 030 public ClassPointcut allClasses() { 031 return new DynaopClassPointcut(Pointcuts.ALL_CLASSES); 032 } 033 034 public ClassPointcut instancesOf(Class type) { 035 return new DynaopClassPointcut(Pointcuts.instancesOf(type)); 036 } 037 038 public ClassPointcut className(String regex) { 039 try { 040 return new DynaopClassPointcut(Pointcuts.className(regex)); 041 } catch (MalformedPatternException e) { 042 throw new MalformedRegularExpressionException("malformed class name regular expression", e); 043 } 044 } 045 046 public ClassPointcut oneClass(Class clazz) { 047 return new DynaopClassPointcut(Pointcuts.singleton(clazz)); 048 } 049 050 public ClassPointcut packageName(String packageName) { 051 return new DynaopClassPointcut(Pointcuts.packageName(packageName)); 052 } 053 054 public ClassPointcut intersection(ClassPointcut a, ClassPointcut b) { 055 return new DynaopClassPointcut(Pointcuts.intersection(toDynaopClassCut(a), toDynaopClassCut(b))); 056 } 057 058 public ClassPointcut union(ClassPointcut a, ClassPointcut b) { 059 return new DynaopClassPointcut(Pointcuts.union(toDynaopClassCut(a), toDynaopClassCut(b))); 060 } 061 062 public ClassPointcut not(ClassPointcut classPointcut) { 063 return new DynaopClassPointcut(Pointcuts.not(toDynaopClassCut(classPointcut))); 064 } 065 066 public MethodPointcut allMethods() { 067 return new DynaopMethodPointcut(Pointcuts.ALL_METHODS); 068 } 069 070 public MethodPointcut getMethods() { 071 return new DynaopMethodPointcut(Pointcuts.GET_METHODS); 072 } 073 074 public MethodPointcut isMethods() { 075 return new DynaopMethodPointcut(Pointcuts.IS_METHODS); 076 } 077 078 public MethodPointcut setMethods() { 079 return new DynaopMethodPointcut(Pointcuts.SET_METHODS); 080 } 081 082 public MethodPointcut objectMethods() { 083 return new DynaopMethodPointcut(Pointcuts.OBJECT_METHODS); 084 } 085 086 public MethodPointcut returnType(ClassPointcut classPointcut) { 087 return new DynaopMethodPointcut(Pointcuts.returnType(toDynaopClassCut(classPointcut))); 088 } 089 090 public MethodPointcut signature(String regexp) { 091 try { 092 return new DynaopMethodPointcut(Pointcuts.signature(regexp)); 093 } catch (MalformedPatternException e) { 094 throw new MalformedRegularExpressionException("malformed method signature regular expression", e); 095 } 096 } 097 098 public MethodPointcut oneMethod(Method method) { 099 return new DynaopMethodPointcut(Pointcuts.singleton(method)); 100 } 101 102 public MethodPointcut declaringClass(ClassPointcut classPointcut) { 103 return new DynaopMethodPointcut(Pointcuts.declaringClass(toDynaopClassCut(classPointcut))); 104 } 105 106 public MethodPointcut membersOf(Class clazz) { 107 return new DynaopMethodPointcut(Pointcuts.membersOf(clazz)); 108 } 109 110 public MethodPointcut intersection(MethodPointcut a, MethodPointcut b) { 111 return new DynaopMethodPointcut(Pointcuts.intersection(toDynaopMethodCut(a), toDynaopMethodCut(b))); 112 } 113 114 public MethodPointcut union(MethodPointcut a, MethodPointcut b) { 115 return new DynaopMethodPointcut(Pointcuts.union(toDynaopMethodCut(a), toDynaopMethodCut(b))); 116 } 117 118 public MethodPointcut not(MethodPointcut methodPointcut) { 119 return new DynaopMethodPointcut(Pointcuts.not(toDynaopMethodCut(methodPointcut))); 120 } 121 122 private static dynaop.ClassPointcut toDynaopClassCut(final ClassPointcut nanoCut) { 123 // The purpose of the anonymous inner class adapter below is to allow 124 // users to use union, intersection and not with custom pointcuts (not 125 // instances of dynaop.ClassPointcut). Now we could just wrap nanoCut 126 // with the adapter every time, even if it is already a 127 // dynaop.ClassPointcut. But the extra level of indirection gets a 128 // little 129 // confusing when debugging. Thus the instanceof check. 130 if (nanoCut instanceof dynaop.ClassPointcut) { 131 return (dynaop.ClassPointcut) nanoCut; 132 } else { 133 return new dynaop.ClassPointcut() { 134 public boolean picks(Class clazz) { 135 return nanoCut.picks(clazz); 136 } 137 }; 138 } 139 } 140 141 private static dynaop.MethodPointcut toDynaopMethodCut(final MethodPointcut nanoCut) { 142 // see comment in toDynaopClassCut, above 143 if (nanoCut instanceof dynaop.MethodPointcut) { 144 return (dynaop.MethodPointcut) nanoCut; 145 } else { 146 return new dynaop.MethodPointcut() { 147 public boolean picks(Method method) { 148 return nanoCut.picks(method); 149 } 150 }; 151 } 152 } 153 154 }