Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.type;
  
  import java.util.*;
  
Simple recursive-descent parser for parsing canonical com.fasterxml.jackson.databind.JavaType representations and constructing type instances.

Author(s):
tatu
 
 public class TypeParser
     implements java.io.Serializable
 {
     private static final long serialVersionUID = 1L;
 
     protected final TypeFactory _factory;
         
     public TypeParser(TypeFactory f) {
          = f;
     }
 
     public JavaType parse(String canonical)
         throws IllegalArgumentException
     {
         canonical = canonical.trim();
         MyTokenizer tokens = new MyTokenizer(canonical);
         JavaType type = parseType(tokens);
         // must be end, now
         if (tokens.hasMoreTokens()) {
             throw _problem(tokens"Unexpected tokens after complete type");
         }
         return type;
     }
 
     protected JavaType parseType(MyTokenizer tokens)
         throws IllegalArgumentException
     {
         if (!tokens.hasMoreTokens()) {
             throw _problem(tokens"Unexpected end-of-string");
         }
         Class<?> base = findClass(tokens.nextToken(), tokens);
         // either end (ok, non generic type), or generics
         if (tokens.hasMoreTokens()) {
             String token = tokens.nextToken();
             if ("<".equals(token)) {
                 return ._fromParameterizedClass(baseparseTypes(tokens));
             }
             // can be comma that separates types, or closing '>'
             tokens.pushBack(token);
         }
         return ._fromClass(basenull);
     }
 
     protected List<JavaTypeparseTypes(MyTokenizer tokens)
         throws IllegalArgumentException
     {
         ArrayList<JavaTypetypes = new ArrayList<JavaType>();
         while (tokens.hasMoreTokens()) {
             types.add(parseType(tokens));
             if (!tokens.hasMoreTokens()) break;
             String token = tokens.nextToken();
             if (">".equals(token)) return types;
             if (!",".equals(token)) {
                 throw _problem(tokens"Unexpected token '"+token+"', expected ',' or '>')");
             }
         }
         throw _problem(tokens"Unexpected end-of-string");
     }
 
     protected Class<?> findClass(String classNameMyTokenizer tokens)
     {
         try {
             return ClassUtil.findClass(className);
         } catch (Exception e) {
             if (e instanceof RuntimeException) {
                 throw (RuntimeExceptione;
             }
             throw _problem(tokens"Can not locate class '"+className+"', problem: "+e.getMessage());
         }
     }
 
     protected IllegalArgumentException _problem(MyTokenizer tokensString msg)
     {
         return new IllegalArgumentException("Failed to parse type '"+tokens.getAllInput()
                 +"' (remaining: '"+tokens.getRemainingInput()+"'): "+msg);
     }
 
     final static class MyTokenizer
         extends StringTokenizer
     {
         protected final String _input;
 
         protected int _index;
 
         protected String _pushbackToken;
         
        public MyTokenizer(String str) {            
            super(str"<,>"true);
             = str;
        }
        @Override
        public boolean hasMoreTokens() {
            return ( != null) || super.hasMoreTokens();
        }
        
        @Override
        public String nextToken() {
            String token;
            if ( != null) {
                token = ;
                 = null;
            } else {
                token = super.nextToken();
            }
             += token.length();
            return token;
        }
        public void pushBack(String token) {
             = token;
             -= token.length();
        }
        
        public String getAllInput() { return ; }
        public String getUsedInput() { return .substring(0, ); }
        public String getRemainingInput() { return .substring(); }
    }
New to GrepCode? Check out our FAQ X