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
  16 class JavassistUtils {
  17
  18     ClassPool classPool
  19
  20     @Property
  21     val Lock lock = new ReentrantLock();
  22
  23     new(ClassPool pool) {
  24         classPool = pool;
  25     }
  26
  27     def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
  28         val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
  29         function1.process(method);
  30         it.addMethod(method);
  31     }
  32
  33         def void method(CtClass it, Class<?> returnType, String name, Class<?> parameter1, Class<?> parameter2,  MethodGenerator function1) {
  34         val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter1.asCtClass,parameter2.asCtClass), it);
  35         function1.process(method);
  36         it.addMethod(method);
  37     }
  38
  39
  40     def void staticMethod(CtClass it, Class<?> returnType, String name, Class<?> parameter, MethodGenerator function1) {
  41         val method = new CtMethod(returnType.asCtClass, name, Arrays.asList(parameter.asCtClass), it);
  42         function1.process(method);
  43         it.addMethod(method);
  44     }
  45
  46     def void implementMethodsFrom(CtClass target, CtClass source, MethodGenerator function1) {
  47         for (method : source.methods) {
  48             if (method.declaringClass == source) {
  49                 val redeclaredMethod = new CtMethod(method, target, null);
  50                 function1.process(redeclaredMethod);
  51                 target.addMethod(redeclaredMethod);
  52             }
  53         }
  54     }
  55
  56     def CtClass createClass(String fqn, ClassGenerator cls) {
  57
  58         val target = classPool.makeClass(fqn);
  59         cls.process(target);
  60         return target;
  61     }
  62
  63     def CtClass createClass(String fqn, CtClass superInterface, ClassGenerator cls) {
  64
  65         val target = classPool.makeClass(fqn);
  66         target.implementsType(superInterface);
  67         cls.process(target);
  68         return target;
  69     }
  70
  71     def void implementsType(CtClass it, CtClass supertype) {
  72         checkArgument(supertype.interface, "Supertype must be interface");
  73         addInterface(supertype);
  74     }
  75
  76     def asCtClass(Class<?> class1) {
  77         classPool.get(class1);
  78     }
  79
  80     def CtField field(CtClass it, String name, Class<?> returnValue) {
  81         val field = new CtField(returnValue.asCtClass, name, it);
  82         field.modifiers = Modifier.PUBLIC
  83         addField(field);
  84         return field;
  85     }
  86
  87     def CtField staticField(CtClass it, String name, Class<?> returnValue) {
  88         val field = new CtField(returnValue.asCtClass, name, it);
  89         field.modifiers = Modifier.PUBLIC + Modifier.STATIC
  90         addField(field);
  91         return field;
  92     }
  93
  94     def get(ClassPool pool, Class<?> cls) {
  95         try {
  96             return pool.get(cls.name)
  97         } catch (NotFoundException e) {
  98             pool.appendClassPath(new LoaderClassPath(cls.classLoader));
  99             try {
 100                 return pool.get(cls.name)
 101
 102             } catch (NotFoundException ef) {
 103                 pool.appendClassPath(new ClassClassPath(cls));
 104                 return pool.get(cls.name)
 105             }
 106         }
 107     }
 108 }