1 package org.opendaylight.yangtools.sal.binding.generator.util
3 import javassist.CtClass
4 import javassist.CtMethod
5 import javassist.ClassPool
6 import java.util.Arrays
7 import static com.google.common.base.Preconditions.*;
8 import javassist.CtField
9 import javassist.Modifier
10 import javassist.NotFoundException
11 import javassist.LoaderClassPath
12 import javassist.ClassClassPath
13 import java.util.concurrent.locks.Lock
14 import java.util.concurrent.locks.ReentrantLock
15 import org.slf4j.LoggerFactory
16 import java.util.HashMap
17 import java.util.WeakHashMap
19 class JavassistUtils {
21 private static val LOG = LoggerFactory.getLogger(JavassistUtils);
23 private val loaderClassPaths = new WeakHashMap<ClassLoader,LoaderClassPath>();
28 val Lock lock = new ReentrantLock();
34 def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
35 val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
36 function1.process(method);
40 def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter1, Class<?> parameter2, MethodGenerator function1) {
41 val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter1.asCtClass,parameter2.asCtClass), it);
42 function1.process(method);
47 def void staticMethod(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
48 val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
49 function1.process(method);
53 def void implementMethodsFrom(CtClass target, CtClass source, MethodGenerator function1) {
54 for (method : source.methods) {
55 if (method.declaringClass == source) {
56 val redeclaredMethod = new CtMethod(method, target, null);
57 function1.process(redeclaredMethod);
58 target.addMethod(redeclaredMethod);
63 def CtClass createClass(String fqn, ClassGenerator cls) {
65 val target = classPool.makeClass(fqn);
70 def CtClass createClass(String fqn, CtClass superInterface, ClassGenerator cls) {
72 val target = classPool.makeClass(fqn);
73 target.implementsType(superInterface);
78 def void implementsType(CtClass it, CtClass supertype) {
79 checkArgument(supertype.interface, "Supertype must be interface");
80 addInterface(supertype);
83 def asCtClass(Class<?> class1) {
84 classPool.get(class1);
87 def CtField field(CtClass it, String name, Class<?> returnValue) {
88 val field = new CtField(returnValue.asCtClass, name, it);
89 field.modifiers = Modifier.PUBLIC
94 def CtField staticField(CtClass it, String name, Class<?> returnValue) {
95 val field = new CtField(returnValue.asCtClass, name, it);
96 field.modifiers = Modifier.PUBLIC + Modifier.STATIC
101 def get(ClassPool pool, Class<?> cls) {
103 return pool.get(cls.name)
104 } catch (NotFoundException e) {
105 appendClassLoaderIfMissing(cls.classLoader)
107 return pool.get(cls.name)
108 } catch (NotFoundException ef) {
109 LOG.warn("Appending ClassClassPath for {}",cls);
110 pool.appendClassPath(new ClassClassPath(cls));
112 return pool.get(cls.name)
117 def void appendClassLoaderIfMissing(ClassLoader loader) {
118 if(loaderClassPaths.containsKey(loader)) {
121 val ctLoader = new LoaderClassPath(loader);
122 classPool.appendClassPath(ctLoader);
125 def void ensureClassLoader(Class<?> child) {
126 appendClassLoaderIfMissing(child.classLoader);