binding/yang-binding/src/main/java/org/opendaylight/yangtools/yang/binding/util/StringValueObjectFactory.java

   1 /*
   2  * Copyright (c) 2016 Pantheon Technologies s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.yangtools.yang.binding.util;
   9
  10 import com.google.common.annotations.Beta;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.base.Throwables;
  13 import java.lang.invoke.MethodHandle;
  14 import java.lang.invoke.MethodHandles;
  15 import java.lang.invoke.MethodHandles.Lookup;
  16 import java.lang.invoke.MethodType;
  17 import java.lang.reflect.Constructor;
  18 import java.lang.reflect.Field;
  19 import java.lang.reflect.InvocationTargetException;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 /**
  24  * Utility class for instantiating value-type generated objects with String being the base type. Unlike the normal
  25  * constructor, instances of this class bypass string validation.
  26  *
  27  * THE USE OF THIS CLASS IS DANGEROUS AND SHOULD ONLY BE USED TO IMPLEMENT WELL-AUDITED AND CORRECT UTILITY METHODS
  28  * SHIPPED WITH MODELS TO PROVIDE INSTANTIATION FROM TYPES DIFFERENT THAN STRING.
  29  *
  30  * APPLICATION CODE <em>MUST NOT</em> USE THIS CLASS DIRECTLY. VIOLATING THIS CONSTRAINT HAS SECURITY AND CORRECTNESS
  31  * IMPLICATIONS ON EVERY USER INTERACTING WITH THE RESULTING OBJECTS.
  32  *
  33  * @param <T> Resulting object type
  34  */
  35 @Beta
  36 public final class StringValueObjectFactory<T> {
  37     private static final MethodType CONSTRUCTOR_METHOD_TYPE = MethodType.methodType(Object.class, Object.class);
  38     private static final MethodType SETTER_METHOD_TYPE = MethodType.methodType(void.class, Object.class, String.class);
  39     private static final Logger LOG = LoggerFactory.getLogger(StringValueObjectFactory.class);
  40     private static final Lookup LOOKUP = MethodHandles.lookup();
  41
  42     private final MethodHandle constructor;
  43     private final MethodHandle setter;
  44
  45     private StringValueObjectFactory(final MethodHandle constructor, final MethodHandle setter) {
  46         this.constructor = Preconditions.checkNotNull(constructor);
  47         this.setter = Preconditions.checkNotNull(setter);
  48     }
  49
  50     public static <T> StringValueObjectFactory<T> create(final Class<T> clazz, final String templateString) {
  51         final Constructor<T> stringConstructor;
  52         try {
  53             stringConstructor = clazz.getConstructor(String.class);
  54         } catch (NoSuchMethodException e) {
  55             throw new IllegalArgumentException(String.format("%s does not have a String constructor", clazz), e);
  56         }
  57
  58         final T template;
  59         try {
  60             template = stringConstructor.newInstance(templateString);
  61         } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
  62             throw new IllegalArgumentException(String.format("Failed to instantiate template %s for '%s'", clazz,
  63                 templateString), e);
  64         }
  65
  66         final Constructor<T> copyConstructor;
  67         try {
  68             copyConstructor = clazz.getConstructor(clazz);
  69         } catch (NoSuchMethodException e) {
  70             throw new IllegalArgumentException(String.format("%s does not have a copy constructor", clazz), e);
  71         }
  72
  73         final Field f;
  74         try {
  75             f = clazz.getDeclaredField("_value");
  76         } catch (NoSuchFieldException e) {
  77             throw new IllegalArgumentException(String.format("%s does not have required internal field", clazz), e);
  78         }
  79         f.setAccessible(true);
  80
  81         final StringValueObjectFactory<T> ret;
  82         try {
  83             ret = new StringValueObjectFactory<>(
  84                     LOOKUP.unreflectConstructor(copyConstructor).asType(CONSTRUCTOR_METHOD_TYPE).bindTo(template),
  85                     LOOKUP.unreflectSetter(f).asType(SETTER_METHOD_TYPE));
  86         } catch (IllegalAccessException e) {
  87             throw new IllegalStateException("Failed to instantiate method handles", e);
  88         }
  89
  90         // Let us be very defensive and scream loudly if the invocation does not come from the same package. This
  91         // is far from perfect, but better than nothing.
  92         final Throwable t = new Throwable("Invocation stack");
  93         t.fillInStackTrace();
  94         if (matchesPackage(clazz.getPackage(), t.getStackTrace())) {
  95             LOG.info("Instantiated factory for {}", clazz);
  96         } else {
  97             LOG.warn("Instantiated factory for {} outside its package", clazz, t);
  98         }
  99
 100         return ret;
 101     }
 102
 103     private static boolean matchesPackage(final Package pkg, final StackTraceElement[] stackTrace) {
 104         for (StackTraceElement e : stackTrace) {
 105             if (pkg.equals(e.getClass().getPackage())) {
 106                 return true;
 107             }
 108         }
 109
 110         return false;
 111     }
 112
 113     public T newInstance(final String string) {
 114         Preconditions.checkNotNull(string, "Argument may not be null");
 115
 116         try {
 117             final T ret = (T) constructor.invokeExact();
 118             setter.invokeExact(ret, string);
 119             LOG.trace("Instantiated new object {} value {}", ret.getClass(), string);
 120             return ret;
 121         } catch (Throwable e) {
 122             throw Throwables.propagate(e);
 123         }
 124     }
 125 }