/** * Creates a parameterized type without an owner type or with a non-generic owner type. * * @param rawType A raw version of the type to describe as a parameterized type. * @param parameter The type arguments to attach to the raw type as parameters. * @return A builder for creating a parameterized type. */ public static Builder parameterizedType(Class<?> rawType, java.lang.reflect.Type... parameter) { return parameterizedType(rawType, Arrays.asList(parameter)); }
/** * Creates a parameterized type without an owner type or with a non-generic owner type. * * @param rawType A raw version of the type to describe as a parameterized type. * @param parameter The type arguments to attach to the raw type as parameters. * @return A builder for creating a parameterized type. */ public static Builder parameterizedType(TypeDescription rawType, TypeDefinition... parameter) { return parameterizedType(rawType, Arrays.asList(parameter)); }
throw new IllegalArgumentException("Require at least one enumeration constant"); TypeDescription.Generic enumType = TypeDescription.Generic.Builder.parameterizedType(Enum.class, TargetType.class).build(); return new SubclassDynamicTypeBuilder<Enum<?>>(instrumentedTypeFactory.subclass(namingStrategy.subclass(enumType), ModifierContributor.Resolver.of(Visibility.PUBLIC, TypeManifestation.FINAL, EnumerationState.ENUMERATION).resolve(),
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 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(); } }
/** * Creates a parameterized type. * * @param rawType A raw version of the type to describe as a parameterized type. * @param ownerType The owner type of the parameterized type. * @param parameters The type arguments to attach to the raw type as parameters. * @return A builder for creating a parameterized type. */ public static Builder parameterizedType(Class<?> rawType, java.lang.reflect.Type ownerType, List<? extends java.lang.reflect.Type> parameters) { return parameterizedType(ForLoadedType.of(rawType), ownerType == null ? null : Sort.describe(ownerType), new TypeList.Generic.ForLoadedTypes(parameters)); }
/** * Creates a parameterized type without an owner type or with a non-generic owner type. * * @param rawType A raw version of the type to describe as a parameterized type. * @param parameters The type arguments to attach to the raw type as parameters. * @return A builder for creating a parameterized type. */ public static Builder parameterizedType(Class<?> rawType, List<? extends java.lang.reflect.Type> parameters) { return parameterizedType(rawType, UNDEFINED, parameters); }
/** * Creates a parameterized type without an owner type or with a non-generic owner type. * * @param rawType A raw version of the type to describe as a parameterized type. * @param parameters The type arguments to attach to the raw type as parameters. * @return A builder for creating a parameterized type. */ public static Builder parameterizedType(TypeDescription rawType, Collection<? extends TypeDefinition> parameters) { return parameterizedType(rawType, Generic.UNDEFINED, parameters); }