How to use

ArrayType

in

org.jboss.jandex

private static String getBindingKey(ArrayType type) {
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i < type.dimensions(); i++) {
    sb.append('[');
  }
  sb.append(getGeneralTypeBindingKey(type.component()));
  return null;
}

  Type copyType(Type component, int dimensions) {
    return new ArrayType(component, dimensions, annotationArray());
  }
}

private void appendArraySyntax(StringBuilder builder) {
  if (annotationArray().length > 0) {
    builder.append(' ');
    appendAnnotations(builder);
  }
  for (int i = 0; i < dimensions; i++) {
    builder.append("[]");
  }
  if (component.kind() == Kind.ARRAY) {
    component.asArrayType().appendArraySyntax(builder);
  }
}

public String toString() {
  StringBuilder builder = new StringBuilder();
  appendRootComponent(builder);
  appendArraySyntax(builder);
  return builder.toString();
}

case ARRAY: {
  ArrayType arrayType = type.asArrayType();
  int dimensions = arrayType.dimensions();
  while (--dimensions > 0 && elements.size() > 0 && elements.peek().kind == PathElement.Kind.ARRAY) {
    elements.pop();
  Type nested = dimensions > 0 ? new ArrayType(arrayType.component(), dimensions) : arrayType.component();
  nested = resolveTypePath(nested, typeAnnotationState);
  return intern(arrayType.copyType(nested, arrayType.dimensions() - dimensions));

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

@Override
Type copyType(AnnotationInstance[] newAnnotations) {
  return new ArrayType(component, dimensions, newAnnotations);
}

@Override
public int dimensions() {
  return getType().dimensions();
}

private void appendRootComponent(StringBuilder builder) {
  if (component.kind() == Kind.ARRAY) {
    component.asArrayType().appendRootComponent(builder);
  } else {
    builder.append(component);
  }
}

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

return "[" + toString( ( (ArrayType) p ).component()); //$NON-NLS-1$

/**
 * Create a new mock array type instance with the specified component
 * and dimensions.
 *
 * @param component the array component
 * @param dimensions the number of dimensions of this array
 * @return the new mock array type instance
 * @since 2.1
 */
public static ArrayType create(Type component, int dimensions) {
  return new ArrayType(component, dimensions);
}

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");
}

  break;
case ARRAY:
  addType(type.asArrayType().component());
  break;
case TYPE_VARIABLE: {

private Type parseArrayType() {
  int mark = this.pos;
  int last = advanceNot('[');
  return new ArrayType(parseJavaType(), last - mark);
}

case ARRAY:
  ArrayType arrayType = type.asArrayType();
  stream.writePackedU32(arrayType.dimensions());
  writeReference(stream, arrayType.component(), false);  // TODO - full should not be necessary
  break;
case PRIMITIVE:

private Type parseType(String descriptor, IntegerHolder pos) {
  int start = pos.i;
  char c = descriptor.charAt(start);
  Type type = PrimitiveType.decode(c);
  if (type != null) {
    return type;
  }
  DotName name;
  switch (c) {
    case 'V': return VoidType.VOID;
    case 'L': {
      int end = start;
      while (descriptor.charAt(++end) != ';');
      name = names.convertToName(descriptor.substring(start + 1, end), '/');
      pos.i = end;
      return names.intern(new ClassType(name));
    }
    case '[': {
      int end = start;
      while (descriptor.charAt(++end) == '[');
      int depth = end - start;
      pos.i = end;
      type = parseType(descriptor, pos);
      return names.intern(new ArrayType(type, depth));
    }
    default: throw new IllegalArgumentException("Invalid descriptor: " + descriptor + " pos " + start);
  }
}

    return new ArrayType(type, depth);
  return new ArrayType(type, depth);
case CLASS:
  return new ClassType(name);

Type component = typeTable[stream.readPackedU32()];
AnnotationInstance[] annotations = readAnnotations(stream, null);
return new ArrayType(component, dimensions, annotations);