Parsing generic type description

Question

I'm trying to write an utility method which allows me to get the definition of a field, including all generic arguments. To do so, I retrieve the generic type of a field via Field.getGenericType() and parse the type name which has the following syntax (in EBNF):

generictype = classname [ '<' generictype { ',' ' ' generictype } '>' ]
classname   = package '.' ( letter | '_' ) { letter | digit | '_' }
package     = ( packagepart { '.' packagepart } ) |
packagepart = ( letter | '_' ) { letter | digit | '_' }

My first attempt to parse this was by using the regular expression

(?<argument>\w+(?:\.\w+)*(?:\<(?<arglist>\g<argument>(?:,\s\g<argument>)*)\>)?)

whose details can be inspected here. This regular expression is just what I need. Now, Java regex does not support the \g<name> construct, so I can't use this approach if I want to support generic types with an unknown depth in their arguments.

Is there any other approach that I can use? If yes, how can I achieve what I'm trying to do?

---

EDIT: The reason I want to achieve this is because I have a configuration and want to transfer its contents into the respective fields of an object. Some sort of deserialization, if you want to call it that way. Now, the configuration only supports primitive types, java.lang.String, java.util.List<T>, java.util.Map<K, V> and java.util.Map.Entry<K, V>. To retrieve values of those classes, the client has to provide a class as parameter which will be used to deserialize the strings that are saved in the configuration. Because of that, I have to determine which generic parameters a field of a class used and also which Classes they correspond to.

Answer 1

You can do the following:

Type type = Field.getGenericType();
if (type instanceof ParameterizedType) {
    ParameterizedType pt = (ParameterizedType) type;
    Class<?> genericType  = (Class<?>) pt.getActualTypeArguments()[0];
}

If this is not enough, just use the google reflections library : https://github.com/google/guava/wiki/ReflectionExplained

Answer 2

If you really need to parse (highstakes' approach looks more elegant, but parsing is what the question asks for), I'd do this with recursive descent parsing, something like this:

class GenericType {
  String baseName;
  List<GenericType> params;

  GenericType(String baseName, List<GenericType> params) {
    this.baseName = baseName;
    this.params = params;
  }

  static GenericType parse(String s) {
    StreamTokenizer tokenizer = new StreamTokenizer(new StringReader(s));
    tokenizer.wordChars('.', '.');  // Make dots part of the name
    try {
      tokenizer.nextToken();  // Skip "BOF" token
      return parse(tokenizer);
    } catch (IOException e) {
      throw new RuntimeException();
    }
  }

  static GenericType parse(StreamTokenizer tokenizer) throws IOException {
    String baseName = tokenizer.sval;
    tokenizer.nextToken();
    List<GenericType> params = new ArrayList<>();
    if (tokenizer.ttype == '<') {
      do {
        tokenizer.nextToken();  // Skip '<' or ','
        params.add(parse(tokenizer));
      } while (tokenizer.ttype == ',');
      tokenizer.nextToken();  // skip '>'
    }
    return new GenericType(baseName, params);
  }
}

Answer 3

I found a solution here, at a question which is trying to do exactly the same, the only difference is that it's in C#. Due to that difference, I had to rewrite the code by Erik_at_Digit a little bit and eventually ended up with this solution:

public class ClassUtil {
    // https://stackoverflow.com/questions/20532691/how-to-parse-c-sharp-generic-type-names?rq=1
    static List<String> splitByComma(String typeArgumentList) {
        List<String> strings = new LinkedList<>();
        StringBuilder sb = new StringBuilder();
        int level = 0;

        for (int i = 0; i < typeArgumentList.length(); i++) {
            char c = typeArgumentList.charAt(i);
            if (c == ',' && level == 0) {
                strings.add(sb.toString());
                sb.setLength(0);
            } else {
                sb.append(c);
            }

            if (c == '<') {
                level++;
            }
            if (c == '>') {
                level--;
            }
        }

        strings.add(sb.toString());

        return strings;
    }

    static GenericType getGenericType(String description) throws ClassNotFoundException {
        Type type;
        GenericType[] parameters;
        if (!description.contains("<")) {
            type = Class.forName(description);
            parameters = new GenericType[0];
        } else {
            int start = description.indexOf('<');
            int end = description.lastIndexOf('>');
            String typeArgumentList = description.substring(start + 1, end);
            String name = description.substring(0, start);
            List<String> arguments = splitByComma(typeArgumentList);

            type = Class.forName(name);
            parameters = new GenericType[arguments.size()];

            for (int i = 0; i < arguments.size(); i++) {
                String argument = arguments.get(i).trim();
                parameters[i] = getGenericType(argument);
            }
        }

        return new GenericType(type, parameters);
    }

    public static GenericType getGenericType(Type type) throws ClassNotFoundException {
        String description = type.getTypeName();
        if (!description.contains("<")) return new GenericType(type);
        return getGenericType(description);
    }

    static List<Map<List<String>, Object>> field = new LinkedList<>();

    public static void main(String[] args) throws Throwable {
        Field field = ClassUtil.class.getDeclaredField("field");
        System.out.println(field.getGenericType());
        System.out.println(getGenericType(field.getGenericType()));
    }

    static class GenericType implements Type {
        final String        typeName;
        final Type          type;
        final GenericType[] parameters;

        public GenericType(Type type, GenericType... parameters) {
            this.type = type;
            this.parameters = parameters;
            typeName = buildTypeName(type, parameters);
        }

        private static String buildTypeName(Type type, GenericType... parameters) {
            StringBuilder s = new StringBuilder();
            s.append(type.getTypeName());

            if (parameters.length > 0) {
                CharSequence[] names = new CharSequence[parameters.length];
                for (int i = 0; i < parameters.length; i++) {
                    names[i] = parameters[i].getTypeName();
                }
                s.append("<").append(String.join(", ", names)).append(">");
            }

            return s.toString();
        }

        @Override
        public String toString() {
            return getTypeName();
        }

        @Override
        public String getTypeName() {
            return typeName;
        }
    }
}

This surely isn't the solution with the best performance or anything but it does what it was designed to do.