Examples with Type org.glassfish.hk2.classmodel.reflect.Type used on opensource projects

Example 26 with Type

use of org.glassfish.hk2.classmodel.reflect.Type in project Payara by payara.

the class ProviderImplGenerator method generateClassData.

public byte[] generateClassData(FlashlightProbeProvider provider, Class providerClazz, String generatedClassName) {
    Type classType = Type.getType(providerClazz);
    if (logger.isLoggable(Level.FINE)) {
        logger.fine("** classType: " + classType);
        logger.fine("** classDesc: " + Type.getDescriptor(providerClazz));
        logger.fine("Generating for: " + generatedClassName);
    }
    generatedClassName = generatedClassName.replace('.', '/');
    int cwFlags = ClassWriter.COMPUTE_FRAMES + ClassWriter.COMPUTE_MAXS;
    ClassWriter cw = new ClassWriter(cwFlags);
    int access = Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL;
    String[] interfaces = new String[] { providerClazz.getName().replace('.', '/') };
    cw.visit(Opcodes.V1_5, access, generatedClassName, null, "java/lang/Object", interfaces);
    for (FlashlightProbe probe : provider.getProbes()) {
        Type probeType = Type.getType(FlashlightProbe.class);
        int fieldAccess = Opcodes.ACC_PUBLIC;
        String fieldName = "_flashlight_" + probe.getProbeName();
        cw.visitField(fieldAccess, fieldName, probeType.getDescriptor(), null, null);
    }
    Type probeType = Type.getType(FlashlightProbe.class);
    for (FlashlightProbe probe : provider.getProbes()) {
        StringBuilder methodDesc = new StringBuilder();
        methodDesc.append("void ").append(probe.getProviderJavaMethodName());
        methodDesc.append("(");
        String delim = "";
        for (Class paramType : probe.getParamTypes()) {
            methodDesc.append(delim).append(paramType.getName());
            delim = ", ";
        }
        methodDesc.append(")");
        Method m = Method.getMethod(methodDesc.toString());
        GeneratorAdapter gen = new GeneratorAdapter(Opcodes.ACC_PUBLIC, m, null, null, cw);
        String fieldName = "_flashlight_" + probe.getProbeName();
        gen.loadThis();
        gen.visitFieldInsn(Opcodes.GETFIELD, generatedClassName, fieldName, probeType.getDescriptor());
        int index = gen.newLocal(probeType);
        gen.storeLocal(index);
        gen.loadLocal(index);
        gen.invokeVirtual(probeType, Method.getMethod("boolean isEnabled()"));
        gen.push(true);
        Label enabledLabel = new Label();
        Label notEnabledLabel = new Label();
        gen.ifCmp(Type.getType(boolean.class), GeneratorAdapter.EQ, enabledLabel);
        gen.goTo(notEnabledLabel);
        gen.visitLabel(enabledLabel);
        gen.loadLocal(index);
        gen.loadArgArray();
        gen.invokeVirtual(probeType, Method.getMethod("void fireProbe(Object[])"));
        gen.visitLabel(notEnabledLabel);
        gen.returnValue();
        gen.endMethod();
    }
    generateConstructor(cw, generatedClassName, provider);
    cw.visitEnd();
    byte[] classData = cw.toByteArray();
    int index = generatedClassName.lastIndexOf('.');
    String clsName = generatedClassName.substring(index + 1);
    if (Boolean.parseBoolean(System.getenv("AS_DEBUG"))) {
        if (logger.isLoggable(Level.FINE))
            logger.fine("Generated ClassDATA " + clsName);
        // the path is horribly long.  Let's just write t directly into the
        // lib dir.  It is not for loading as a class but just for us humans
        // to decompile to figure out what is going on.  No need to make it even harder!
        clsName = clsName.replace('.', '/');
        // just in case Windows?  unlikely...
        clsName = clsName.replace('\\', '/');
        index = clsName.lastIndexOf("/");
        if (index >= 0)
            clsName = clsName.substring(index + 1);
        FileOutputStream fos = null;
        try {
            String rootPath = System.getProperty(SystemPropertyConstants.INSTALL_ROOT_PROPERTY) + File.separator + "lib" + File.separator;
            String fileName = rootPath + clsName + ".class";
            if (logger.isLoggable(Level.FINE))
                logger.fine("ClassFile: " + fileName);
            File file = new File(fileName);
            if (FileUtils.mkdirsMaybe(file.getParentFile())) {
                fos = new FileOutputStream(file);
                fos.write(classData);
                fos.flush();
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (fos != null)
                    fos.close();
            } catch (Exception e) {
            // nothing can be done...
            }
        }
    }
    return classData;
}

Example 27 with Type

use of org.glassfish.hk2.classmodel.reflect.Type in project Payara by payara.

the class InjectionManager method syncDoInject.

/**
 * Initializes the component by performing injection.
 *
 * @param component component instance to inject
 * @param onBehalfOf the inhabitant to do injection on behalf of
 * @param type component class
 * @param targets the injection resolvers to resolve all injection points
 * @throws ComponentException
 *      if injection failed for some reason.
 */
protected void syncDoInject(Object component, Class type, InjectionResolver... targets) {
    assert component != null;
    try {
        Class currentClass = type;
        while (currentClass != null && Object.class != currentClass) {
            // get the list of the instances variable
            for (Field field : currentClass.getDeclaredFields()) {
                Annotation nonOptionalAnnotation = null;
                boolean injected = false;
                for (InjectionResolver target : targets) {
                    Annotation inject = field.getAnnotation(target.type);
                    if (inject == null)
                        continue;
                    Type genericType = field.getGenericType();
                    Class fieldType = field.getType();
                    try {
                        Object value = target.getValue(component, field, genericType, fieldType);
                        if (value != null) {
                            AccessController.doPrivileged(new PrivilegedAction<Field>() {

                                @Override
                                public Field run() {
                                    field.setAccessible(true);
                                    return field;
                                }
                            });
                            field.set(component, value);
                            injected = true;
                            break;
                        } else {
                            if (!target.isOptional(field, inject)) {
                                nonOptionalAnnotation = inject;
                            }
                        }
                    } catch (MultiException e) {
                        error_injectionException(target, inject, field, e);
                    } catch (IllegalAccessException e) {
                        error_injectionException(target, inject, field, e);
                    } catch (RuntimeException e) {
                        error_injectionException(target, inject, field, e);
                    } catch (Exception ex) {
                        error_injectionException(target, inject, field, ex);
                    }
                }
                // exhausted all injection managers,
                if (!injected && nonOptionalAnnotation != null) {
                    throw new UnsatisfiedDependencyException(field, nonOptionalAnnotation);
                }
            }
            for (Method method : currentClass.getDeclaredMethods()) {
                for (InjectionResolver target : targets) {
                    Annotation inject = method.getAnnotation(target.type);
                    if (inject == null)
                        continue;
                    Method setter = target.getSetterMethod(method, inject);
                    if (setter.getReturnType() != void.class) {
                        if (Collection.class.isAssignableFrom(setter.getReturnType())) {
                            injectCollection(component, setter, target.getValue(component, method, null, setter.getReturnType()));
                            continue;
                        }
                        error_InjectMethodIsNotVoid(method);
                    }
                    Class<?>[] paramTypes = setter.getParameterTypes();
                    Type[] genericParamTypes = setter.getGenericParameterTypes();
                    if (allowInjection(method, paramTypes)) {
                        try {
                            if (1 == paramTypes.length) {
                                Object value = target.getValue(component, method, genericParamTypes[0], paramTypes[0]);
                                if (value != null) {
                                    AccessController.doPrivileged(new PrivilegedAction<Method>() {

                                        @Override
                                        public Method run() {
                                            setter.setAccessible(true);
                                            return setter;
                                        }
                                    });
                                    setter.invoke(component, value);
                                } else {
                                    if (!target.isOptional(method, inject)) {
                                        throw new UnsatisfiedDependencyException(method, inject);
                                    }
                                }
                            } else {
                                // multi params
                                AccessController.doPrivileged(new PrivilegedAction<Method>() {

                                    @Override
                                    public Method run() {
                                        setter.setAccessible(true);
                                        return setter;
                                    }
                                });
                                Type[] gparamType = setter.getGenericParameterTypes();
                                Object[] params = new Object[paramTypes.length];
                                for (int i = 0; i < paramTypes.length; i++) {
                                    Object value = target.getValue(component, method, gparamType[i], paramTypes[i]);
                                    if (value != null) {
                                        params[i] = value;
                                    } else {
                                        if (!target.isOptional(method, inject)) {
                                            throw new UnsatisfiedDependencyException(method, inject);
                                        }
                                    }
                                }
                                setter.invoke(component, params);
                            }
                        } catch (MultiException e) {
                            error_injectionException(target, inject, setter, e);
                        } catch (IllegalAccessException e) {
                            error_injectionException(target, inject, setter, e);
                        } catch (InvocationTargetException e) {
                            error_injectionException(target, inject, setter, e);
                        } catch (RuntimeException e) {
                            error_injectionException(target, inject, setter, e);
                        }
                    }
                }
            }
            currentClass = currentClass.getSuperclass();
        }
    } catch (final LinkageError e) {
        // reflection could trigger additional classloading and resolution, so it can cause linkage error.
        // report more information to assist diagnosis.
        // can't trust component.toString() as the object could be in an inconsistent state.
        final Class<?> cls = type;
        AccessController.doPrivileged(new PrivilegedAction<Object>() {

            @Override
            public Object run() {
                LinkageError x = new LinkageError("injection failed on " + cls + " from " + cls.getClassLoader());
                x.initCause(e);
                throw x;
            }
        });
    }
}

Example 28 with Type

use of org.glassfish.hk2.classmodel.reflect.Type in project athenz by yahoo.

the class AthenzJettyContainer method addContainerRequestFilter.

public <T> void addContainerRequestFilter(ResourceConfig rconf, final Class<T> targetType) {
    AbstractBinder binder = new AbstractBinder() {

        Class<T> type = targetType;

        @Override
        protected void configure() {
            bind(type).to(javax.ws.rs.container.ContainerRequestFilter.class);
        }
    };
    rconf.register(binder);
}

Example 29 with Type

use of org.glassfish.hk2.classmodel.reflect.Type in project jersey by jersey.

the class ContextInjectionResolverImpl method resolve.

@Override
public Object resolve(Injectee injectee, ServiceHandle<?> root) {
    Type requiredType = injectee.getRequiredType();
    boolean isHk2Factory = ReflectionHelper.isSubClassOf(requiredType, Factory.class);
    Injectee newInjectee;
    if (isHk2Factory) {
        newInjectee = getFactoryInjectee(injectee, ReflectionHelper.getTypeArgument(requiredType, 0));
    } else {
        newInjectee = foreignRequestScopedInjecteeCache.apply(injectee);
    }
    ActiveDescriptor<?> ad = descriptorCache.apply(newInjectee);
    if (ad != null) {
        final ServiceHandle handle = serviceLocator.getServiceHandle(ad, newInjectee);
        if (isHk2Factory) {
            return asFactory(handle);
        } else {
            return handle.getService();
        }
    }
    return null;
}

Example 30 with Type

use of org.glassfish.hk2.classmodel.reflect.Type in project dropwizard by dropwizard.

the class OptionalParamConverterProvider method getConverter.

/**
     * {@inheritDoc}
     */
@Override
public <T> ParamConverter<T> getConverter(final Class<T> rawType, final Type genericType, final Annotation[] annotations) {
    if (Optional.class.equals(rawType)) {
        final List<ClassTypePair> ctps = ReflectionHelper.getTypeArgumentAndClass(genericType);
        final ClassTypePair ctp = (ctps.size() == 1) ? ctps.get(0) : null;
        if (ctp == null || ctp.rawClass() == String.class) {
            return new ParamConverter<T>() {

                @Override
                public T fromString(final String value) {
                    return rawType.cast(Optional.ofNullable(value));
                }

                @Override
                public String toString(final T value) {
                    return value.toString();
                }
            };
        }
        for (ParamConverterProvider provider : Providers.getProviders(locator, ParamConverterProvider.class)) {
            final ParamConverter<?> converter = provider.getConverter(ctp.rawClass(), ctp.type(), annotations);
            if (converter != null) {
                return new ParamConverter<T>() {

                    @Override
                    public T fromString(final String value) {
                        return rawType.cast(Optional.ofNullable(value).map(s -> converter.fromString(value)));
                    }

                    @Override
                    public String toString(final T value) {
                        return value.toString();
                    }
                };
            }
        }
    }
    return null;
}