How to use

ParameterizedType

in

org.jboss.jandex

private static String getBindingKey(ParameterizedType type) {
  StringBuilder sb = new StringBuilder();
  sb.append(type.owner() == null ? "L" + type.name().toString().replace('.', '/') : getGeneralTypeBindingKey(type.owner()));
  sb.append('<');
  for (Type argument : type.arguments()) {
    sb.append(getGeneralTypeBindingKey(argument));
  }
  sb.append('>');
  if (type.owner() == null) {
    sb.append(';');
  }
  return sb.toString();
}

ParameterizedType copyType(Type[] parameters) {
  return new ParameterizedType(name(), parameters, owner, annotationArray());
}

public String toString() {
  StringBuilder builder = new StringBuilder();
  if (owner != null) {
    builder.append(owner);
    builder.append('.');
    appendAnnotations(builder);
    builder.append(name().local());
  } else {
    appendAnnotations(builder);
    builder.append(name());
  }
  if (arguments.length > 0) {
    builder.append('<');
    builder.append(arguments[0]);
    for (int i = 1; i < arguments.length; i++) {
      builder.append(", ").append(arguments[i]);
    }
    builder.append('>');
  }
  return builder.toString();
}

@Override
ParameterizedType copyType(AnnotationInstance[] newAnnotations) {
  return new ParameterizedType(name(), arguments, owner, newAnnotations);
}

case PARAMETERIZED_TYPE:
  ParameterizedType parameterizedType = type.asParameterizedType();
  addClassName(parameterizedType.name());
  addType(parameterizedType.owner());
  addTypeList(parameterizedType.argumentsArray());
  break;
case PRIMITIVE:

@Override
public String name() {
  return getType().name().toString();
}

private Map<DotName, Type> buildOwnerMap(Type type) {
  Map<DotName, Type> pTypeTree = new HashMap<DotName, Type>();
  Type nextType = type;
  do {
    pTypeTree.put(nextType.name(), nextType);
    nextType = nextType instanceof ParameterizedType ? nextType.asParameterizedType().owner() : null;
  } while (nextType != null);
  return pTypeTree;
}

  last = intern(oType != null ? convertParameterized(oType).copyType(last)
                : new ParameterizedType(currentName, null, last));
} else if (oType != null) {
  last = oType;

Type[] arguments = parameterizedType.argumentsArray().clone();
int pos = element.pos;
if (pos >= arguments.length) {
return intern(parameterizedType.copyType(arguments));

/**
 * Create a new mock instance.
 *
 * @param name the name of this type
 * @param arguments an array of types representing arguments to this type
 * @param owner the enclosing type if annotated or parameterized, otherwise null
 * @return the mock instance
 * @since 2.1
 */
public static ParameterizedType create(DotName name, Type[] arguments, Type owner) {
  return new ParameterizedType(name, arguments, owner);
}

@Override
public Stream<IJavaType> arguments() {
  return getType().arguments().stream().map(Wrappers::wrap);
}

private Type searchTypePath(Type type, TypeAnnotationState typeAnnotationState) {
  PathElementStack elements = typeAnnotationState.pathElements;
  PathElement element = elements.pop();
  if (element == null) {
    return type;
  }
  switch (element.kind) {
    case ARRAY: {
      ArrayType arrayType = type.asArrayType();
      int dimensions = arrayType.dimensions();
      while (--dimensions > 0 && elements.size() > 0 && elements.peek().kind == PathElement.Kind.ARRAY) {
        elements.pop();
      }
      assert dimensions == 0;
      return searchTypePath(arrayType.component(), typeAnnotationState);
    }
    case PARAMETERIZED: {
      ParameterizedType parameterizedType = type.asParameterizedType();
      return searchTypePath(parameterizedType.argumentsArray()[element.pos], typeAnnotationState);
    }
    case WILDCARD_BOUND: {
      return searchTypePath(type.asWildcardType().bound(), typeAnnotationState);
    }
    case NESTED: {
      int depth = popNestedDepth(elements);
      return searchNestedType(type, depth, typeAnnotationState);
    }
  }
  throw new IllegalStateException("Unknown path element");
}

case PARAMETERIZED_TYPE:
  ParameterizedType parameterizedType = type.asParameterizedType();
  Type owner = parameterizedType.owner();
  stream.writePackedU32(positionOf(parameterizedType.name()));
  writeReference(stream, owner, true);
  writeReferenceOrFull(stream, parameterizedType.argumentsArray());
  break;

return "L" + ( (ParameterizedType) p ).name().toString().replace('.', '/') + ";"; //$NON-NLS-1$ //$NON-NLS-2$

@Override
public IJavaType owner() {
  return wrap(getType().owner());
}

  ParameterizedType toParameterizedType() {
    return new ParameterizedType(name(), null, null, annotationArray());
  }
}

ParameterizedType copyType(Type owner) {
  return new ParameterizedType(name(), arguments, owner, annotationArray());
}

private Type parseClassTypeSignature() {
  String signature = this.signature;
  DotName name = parseName();
  Type[] types = parseTypeArguments();
  Type type = null;
  if (types.length > 0) {
    type = new ParameterizedType(name, types, null);
  }
  // Suffix
  while (signature.charAt(pos) == '.') {
    int mark = ++pos;
    int suffixEnd = advanceNameEnd();
    name = names.wrap(name, signature.substring(mark, suffixEnd), true);
    types = parseTypeArguments();
    // A suffix is a parameterized type if it has typeParameters or it's owner is a parameterized type
    // The first parameterized type needs a standard class type for the owner
    if (type == null && types.length > 0) {
      type = names.intern(new ClassType(name.prefix()));
    }
    if (type != null) {
      type = names.intern(new ParameterizedType(name, types, type));
    }
  }
  this.pos++; // ;
  return type != null ? type : names.intern(new ClassType(name));
}

Type[] parameters = readTypeListReference(stream);
AnnotationInstance[] annotations = readAnnotations(stream, null);
return new ParameterizedType(name, parameters, owner, annotations);