net.bytebuddy.description.type.TypeDescription.Generic Java Examples

private static <InT, OutT> DynamicType.Unloaded<?> createDynamicTypeFromSpec(StreamingLedgerSpec<InT, OutT> spec)
        throws NoSuchMethodException {
    PackageLocalNamingStrategy generatedTypeName = new PackageLocalNamingStrategy(spec.processFunction.getClass());

    TypeDefinition generatedType = Generic.Builder.parameterizedType(
            ProcessFunctionInvoker.class,
            spec.inputType.getTypeClass(),
            spec.resultType.getTypeClass()
    ).build();

    TypeDefinition processFunctionType = new TypeDescription.ForLoadedType(spec.processFunction.getClass());
    ForLoadedConstructor superTypeConstructor =
            new ForLoadedConstructor(ProcessFunctionInvoker.class.getDeclaredConstructor());
    MethodDescription processMethodType = processMethodTypeFromSpec(spec);

    Builder<?> builder = configureByteBuddyBuilder(
            generatedTypeName,
            generatedType,
            processFunctionType,
            superTypeConstructor,
            processMethodType,
            spec.stateBindings.size());

    return builder.make();
}
 

static String fixName(TypeDescription.Generic type, String currentName)
{
    if (type.asErasure().equals(PROVIDER))
    {
        String name = currentName.toLowerCase();
        int providerIndex = name.indexOf("provider");
        if (providerIndex != - 1)
        {
            name = currentName.substring(0, providerIndex);
        }
        else
        {
            name = currentName;
        }
        return name;
    }
    else
    {
        return currentName;
    }
}
 

<T, B extends AnnotatedCodeElement & NamedElement.WithRuntimeName> ControllerInjectValueData<T> createValue
        (int index, TypeDescription classType, TypeDescription.ForLoadedType.Generic type, B member, String name,
         Map<Class<? extends Annotation>, ? extends Annotation> parentRawScopeAnnotations,
         Map<Class<? extends Annotation>, ? extends Annotation> parentRawQualifierAnnotations)
{
    Map<Class<? extends Annotation>, ? extends Annotation> scopeAnnotations;
    {
        Map<Class<? extends Annotation>, ? extends Annotation> memberRawScopeAnnotations = this.extractRawScopeAnnotations(member);
        Map<Class<? extends Annotation>, Annotation> rawScopeAnnotations = new HashMap<>(parentRawScopeAnnotations);
        rawScopeAnnotations.putAll(memberRawScopeAnnotations);
        scopeAnnotations = this.transformAll(classType, name, member, rawScopeAnnotations);
    }
    Map<Class<? extends Annotation>, ? extends Annotation> qualifierAnnotations;
    {
        Map<Class<? extends Annotation>, ? extends Annotation> memberRawQualifierAnnotations = this.extractRawQualifierAnnotations(member);
        Map<Class<? extends Annotation>, Annotation> rawQualifierAnnotations = new HashMap<>(parentRawQualifierAnnotations);
        rawQualifierAnnotations.putAll(memberRawQualifierAnnotations);
        qualifierAnnotations = this.transformAll(classType, name, member, rawQualifierAnnotations);
    }
    return new ControllerInjectValueData<>(index, name, type, scopeAnnotations, qualifierAnnotations);
}
 

static TypeDefinition createTypeDefinitionFromJavaType(JavaType javaType) {
    if (!javaType.hasGenericTypes()) {
        //simply use the raw class to construct the corresponding TypeDefinition
        return new TypeDescription.ForLoadedType(javaType.getRawClass());
    }
    //create the appropriate Generic TypeDescription using containedType values
    final List<Type> genericParameters = new ArrayList<Type>();
    for(int i=0; i<javaType.containedTypeCount(); i++) {
        genericParameters.add(javaType.containedType(i).getRawClass());
    }
    return Generic.Builder.parameterizedType(javaType.getRawClass(), genericParameters).build();
}
 

private static boolean isAccessor(MethodDescription method) {
    if (method.getDeclaringType().represents(Object.class)) {
        return false;
    }
    String methodName = method.getName();
    Generic returnType = method.getReturnType();
    ParameterList<?> args = method.getParameters();

    boolean isSetter = Generic.VOID.equals(returnType) && args.size() == 1
            && ReflectTools.isSetterName(methodName);
    boolean isGetter = !Generic.VOID.equals(returnType) && args.isEmpty()
            && ReflectTools.isGetterName(methodName,
                    returnType.represents(boolean.class));
    return isSetter || isGetter;
}
 

public boolean isCompatible(InjectValueData<?, Generic> injectValueData)
{
    if (! this.typePredicate.test(injectValueData.getType()))
    {
        return false;
    }
    for (QualifierPattern qualifier : this.qualifiers)
    {
        if (! qualifier.test(injectValueData))
        {
            return false;
        }
    }
    return true;
}
 

ControllerInjectValueData(int index, String name, Generic type, Map<Class<? extends Annotation>, ? extends Annotation> scopes,
                          Map<Class<? extends Annotation>, ? extends Annotation> qualifiers)
{
    this.index = index;
    this.name = name;
    this.type = type;
    this.scopes = scopes;
    this.qualifiers = qualifiers;
    this.isProvider = type.asErasure().equals(Controller.PROVIDER);
}
 

@Override
public void rebind()
{
    Lock writeLock = this.lock.writeLock();
    try
    {
        writeLock.lock();
        for (org.diorite.inject.impl.data.ClassData<TypeDescription.ForLoadedType.Generic> classData : this.dataList)
        {
            this.rebindSingle(classData);
        }
        for (BinderValueData bindValue : this.bindValues)
        {
            Collection<? extends InjectValueData<?, ?>> injectValues = bindValue.getProvider().getInjectValues();
            if (injectValues.isEmpty())
            {
                continue;
            }
            for (InjectValueData<?, ?> valueData : injectValues)
            {
                this.findBinder((ControllerInjectValueData<?>) valueData);
            }
        }
    }
    finally
    {
        writeLock.unlock();
    }
}
 

private void rebindSingle(org.diorite.inject.impl.data.ClassData<TypeDescription.ForLoadedType.Generic> classData)
{
    Collection<org.diorite.inject.impl.data.InjectValueData<?, Generic>> allData = new ArrayList<>(100);
    for (org.diorite.inject.impl.data.MemberData<TypeDescription.ForLoadedType.Generic> fieldData : classData.getMembers())
    {
        allData.addAll(fieldData.getInjectValues());
    }
    for (org.diorite.inject.impl.data.InjectValueData<?, TypeDescription.ForLoadedType.Generic> valueData : allData)
    {
        this.findBinder(valueData);
    }
}
 

private void rebindSingleWithLock(org.diorite.inject.impl.data.ClassData<TypeDescription.ForLoadedType.Generic> classData)
{
    Lock writeLock = this.lock.writeLock();
    try
    {
        writeLock.lock();
        this.rebindSingle(classData);
    }
    finally
    {
        writeLock.unlock();
    }
}
 

@Override
protected ControllerClassData addClassData(TypeDescription typeDescription,
                                           org.diorite.inject.impl.data.ClassData<TypeDescription.ForLoadedType.Generic> classData)
{
    if (! (classData instanceof ControllerClassData))
    {
        throw new IllegalArgumentException("Unsupported class data for this controller");
    }
    this.map.put(typeDescription, classData);
    Lock lock = this.lock.writeLock();
    try
    {
        lock.lock();
        ((ControllerClassData) classData).setIndex(this.dataList.size());
        this.dataList.add(classData);
    }
    finally
    {
        lock.unlock();
    }
    try
    {
        ByteBuddyAgent.getInstrumentation().retransformClasses(AsmUtils.toClass(typeDescription));
    }
    catch (Exception e)
    {
        throw new TransformerError(e);
    }
    return (ControllerClassData) classData;
}
 

@Override
public void addClassData(Class<?> clazz)
{
    org.diorite.inject.impl.data.ClassData<Generic> classData = this.addClassData(new ForLoadedType(clazz));
    if (classData != null)
    {
        this.rebindSingleWithLock(classData);
    }
}
 

private void bind()
{
    Predicate<Generic> typePredicate =
            type -> type.asErasure().equals(Controller.PROVIDER) ?
                    this.typePredicate.test(type.getTypeArguments().get(0)) :
                    this.typePredicate.test(type);
    BinderValueData valueData = BinderValueData.dynamic(typePredicate, this.patterns, this.provider);
    this.diController.bindValues.add(valueData);
}
 

public <T> Binder<T> bindToType(Predicate<Generic> typePredicate)
{
    return new BinderSimpleInstance<>(this, typePredicate);
}
 

BinderSimpleValueData(Predicate<Generic> typePredicate, Collection<QualifierPattern> qualifiers, Provider<?> provider)
{
    super(typePredicate, qualifiers);
    this.provider = provider;
}
 

public static void generateMethodInjection(ControllerClassData classData, ControllerMethodData methodData, MethodNode mv, boolean printMethods,
                                           int lineNumber)
{
    MethodDescription.InDefinedShape member = methodData.getMember();
    boolean isStatic = member.isStatic();

    if (printMethods)
    {
        lineNumber = printMethods(mv, classData.getType().getInternalName(), methodData.getBefore(), isStatic, lineNumber);
    }
    lineNumber = AsmUtils.printLineNumber(mv, lineNumber);

    if (! isStatic)
    {
        mv.visitVarInsn(ALOAD, 0);
    }

    for (InjectValueData<?, Generic> valueData : methodData.getInjectValues())
    {
        if (isStatic)
        {
            mv.visitInsn(ACONST_NULL);
        }
        else
        {
            mv.visitVarInsn(ALOAD, 0);
        }
        AsmUtils.storeInt(mv, classData.getIndex());
        AsmUtils.storeInt(mv, methodData.getIndex());
        AsmUtils.storeInt(mv, valueData.getIndex());
        mv.visitInsn(ICONST_0); // skip null checks in methods.
        lineNumber = AsmUtils.printLineNumber(mv, lineNumber);
        mv.visitMethodInsn(INVOKESTATIC, INJECTOR_CLASS, INJECTOR_METHOD, INJECTOR_METHOD_DESC, false);
        TypeDescription paramType = valueData.getType().asErasure();
        mv.visitTypeInsn(CHECKCAST, paramType.getInternalName()); // skip cast check?
    }

    lineNumber = AsmUtils.printLineNumber(mv, lineNumber);

    if (isStatic)
    {
        mv.visitMethodInsn(INVOKESTATIC, classData.getType().getInternalName(), member.getName(), member.getDescriptor(), false);
    }
    else
    {
        mv.visitMethodInsn(INVOKESPECIAL, classData.getType().getInternalName(), member.getName(), member.getDescriptor(), false);
    }

    if (printMethods)
    {
        printMethods(mv, classData.getType().getInternalName(), methodData.getAfter(), isStatic, lineNumber);
    }
}
 

@Override
public TypeDescription.ForLoadedType.Generic getType()
{
    return this.type;
}
 

BinderValueData(Predicate<TypeDescription.Generic> typePredicate, Collection<QualifierPattern> qualifiers)
{
    this.typePredicate = typePredicate;
    this.qualifiers = qualifiers;
}
 

BinderSimpleInstance(Controller diController, Predicate<Generic> typePredicate)
{
    this.diController = diController;
    this.typePredicate = typePredicate;
}
 

static BinderValueData simple(Predicate<Generic> typePredicate, Collection<QualifierPattern> qualifiers, Provider<?> provider)
{
    return new BinderSimpleValueData(typePredicate, qualifiers, provider);
}
 

static BinderValueData dynamic(Predicate<Generic> typePredicate, Collection<QualifierPattern> qualifiers, DynamicProvider<?> provider)
{
    return new BinderDynamicValueData(typePredicate, qualifiers, provider);
}
 

BinderDynamicValueData(Predicate<Generic> typePredicate, Collection<QualifierPattern> qualifiers, DynamicProvider<?> provider)
{
    super(typePredicate, qualifiers);
    this.provider = provider;
}