opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/util/JavassistUtils.xtend

   1 package org.opendaylight.controller.sal.binding.codegen.util
   2
   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
  18
  19 class JavassistUtils {
  20
  21     private static val LOG = LoggerFactory.getLogger(JavassistUtils);
  22
  23     private val loaderClassPaths = new WeakHashMap<ClassLoader,LoaderClassPath>();
  24
  25     ClassPool classPool
  26
  27     @Property
  28     val Lock lock = new ReentrantLock();
  29
  30     new(ClassPool pool) {
  31         classPool = pool;
  32     }
  33
  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);
  37         it.addMethod(method);
  38     }
  39
  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);
  43         it.addMethod(method);
  44     }
  45
  46
  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);
  50         it.addMethod(method);
  51     }
  52
  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);
  59             }
  60         }
  61     }
  62
  63     def CtClass createClass(String fqn, ClassGenerator cls) {
  64
  65         val target = classPool.makeClass(fqn);
  66         cls.process(target);
  67         return target;
  68     }
  69
  70     def CtClass createClass(String fqn, CtClass superInterface, ClassGenerator cls) {
  71
  72         val target = classPool.makeClass(fqn);
  73         target.implementsType(superInterface);
  74         cls.process(target);
  75         return target;
  76     }
  77
  78     def void implementsType(CtClass it, CtClass supertype) {
  79         checkArgument(supertype.interface, "Supertype must be interface");
  80         addInterface(supertype);
  81     }
  82
  83     def asCtClass(Class<?> class1) {
  84         classPool.get(class1);
  85     }
  86
  87     def CtField field(CtClass it, String name, Class<?> returnValue) {
  88         val field = new CtField(returnValue.asCtClass, name, it);
  89         field.modifiers = Modifier.PUBLIC
  90         addField(field);
  91         return field;
  92     }
  93
  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
  97         addField(field);
  98         return field;
  99     }
 100
 101     def get(ClassPool pool, Class<?> cls) {
 102         try {
 103             return pool.get(cls.name)
 104         } catch (NotFoundException e) {
 105             appendClassLoaderIfMissing(cls.classLoader)
 106             try {
 107                 return pool.get(cls.name)
 108             } catch (NotFoundException ef) {
 109                 LOG.warn("Appending ClassClassPath for {}",cls);
 110                 pool.appendClassPath(new ClassClassPath(cls));
 111
 112                 return pool.get(cls.name)
 113             }
 114         }
 115     }
 116
 117     def void appendClassLoaderIfMissing(ClassLoader loader) {
 118         if(loaderClassPaths.containsKey(loader)) {
 119             return;
 120         }
 121         val ctLoader = new LoaderClassPath(loader);
 122         classPool.appendClassPath(ctLoader);
 123     }
 124
 125     def void ensureClassLoader(Class<?> child) {
 126         appendClassLoaderIfMissing(child.classLoader);
 127     }
 128 }