Create new instance with default parser, a {@link GnuParser}

@param <T> Type of the bean
@param beanType Type of the bean
@return Instance of an implementation of argument processor
423503
public static <T> ArgumentProcessor<T> forType(Class<? extends T> beanType) {
    return newInstance(beanType, new GnuParser());
  }
336689
public static <T> BasicInjectionTarget<T> createNonCdiInterceptor(EnhancedAnnotatedType<T> type, BeanManagerImpl beanManager) {
        return new BasicInjectionTarget<T>(type, null, beanManager, DefaultInjector.of(type, null, beanManager), NoopLifecycleCallbackInvoker.<T>getInstance());
    }
883363
public static <T> JacksonParser<T> json(Class<T> contentType) {
        return new JacksonParser<>(null, contentType);
    }
53336
private static POJODefinition _construct(Class<?> beanType)
    {
        Map<String,Prop> propsByName = new TreeMap<String,Prop>();
        _introspect(beanType, propsByName);

        Constructor<?> defaultCtor = null;
        Constructor<?> stringCtor = null;
        Constructor<?> longCtor = null;

        for (Constructor<?> ctor : beanType.getDeclaredConstructors()) {
            Class<?>[] argTypes = ctor.getParameterTypes();
            if (argTypes.length == 0) {
                defaultCtor = ctor;
            } else if (argTypes.length == 1) {
                Class<?> argType = argTypes[0];
                if (argType == String.class) {
                    stringCtor = ctor;
                } else if (argType == Long.class || argType == Long.TYPE) {
                    longCtor = ctor;
                } else {
                    continue;
                }
            } else {
                continue;
            }
        }
        Prop[] props;
        if (propsByName.isEmpty()) {
            props = NO_PROPS;
        } else {
            props = propsByName.values().toArray(NO_PROPS);
        }
        return new POJODefinition(beanType, props, defaultCtor, stringCtor, longCtor);
    }
1222724
private <T> T parseRoot(Map<String, Object> input, Class<T> declaredType) throws Exception {
        Object parsed = parseBean(input, declaredType);
        return declaredType.cast(parsed);
    }
119346
public JavaType create(ClassIndex index, ClassPlan plan) {

        // base class
        JavaInterfaceSource type = Roaster.parse(
                JavaInterfaceSource.class,
                "public interface " + plan.getClassName() + "Consumer<T extends " + plan.getClassName() + "<T>> {}"
        );

        type.setPackage(plan.getPackageName());

        type.addImport(plan.getPackageName() + "." + plan.getClassName());
        type.addAnnotation(FunctionalInterface.class);

        addAccept(type, plan);
        addAndThen(type, plan);

        return type;
    }
493844
public JaversType getJaversType(Type javaType) {
        argumentIsNotNull(javaType);

        if (javaType == Object.class) {
            return OBJECT_TYPE;
        }

        return engine.computeIfAbsent(javaType, j -> typeFactory.infer(j, findPrototype(j)));
    }
1127863
static BaseTypeSignature parse(final Parser parser) {
        switch (parser.peek()) {
        case 'B':
            parser.next();
            return new BaseTypeSignature("byte");
        case 'C':
            parser.next();
            return new BaseTypeSignature("char");
        case 'D':
            parser.next();
            return new BaseTypeSignature("double");
        case 'F':
            parser.next();
            return new BaseTypeSignature("float");
        case 'I':
            parser.next();
            return new BaseTypeSignature("int");
        case 'J':
            parser.next();
            return new BaseTypeSignature("long");
        case 'S':
            parser.next();
            return new BaseTypeSignature("short");
        case 'Z':
            parser.next();
            return new BaseTypeSignature("boolean");
        case 'V':
            parser.next();
            return new BaseTypeSignature("void");
        default:
            return null;
        }
    }
1194849
public GetterType<BeanType<T>> getOrCreateGetter()
   {
      List<Node> nodeList = childNode.get("getter");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new GetterTypeImpl<BeanType<T>>(this, "getter", childNode, nodeList.get(0));
      }
      return createGetter();
   }
674327
public static <T> T instantiate(Class<T> type) {
        try {
            return BeanIntrospector.SHARED.findIntrospection(type).map(BeanIntrospection::instantiate).orElseGet(() -> {
                try {
                    Logger log = ClassUtils.REFLECTION_LOGGER;
                    if (log.isDebugEnabled()) {
                        log.debug("Reflectively instantiating type: " + type);
                    }
                    return type.newInstance();
                } catch (Throwable e) {
                    throw new InstantiationException("Could not instantiate type [" + type.getName() + "]: " + e.getMessage(), e);
                }
            });
        } catch (Throwable e) {
            throw new InstantiationException("Could not instantiate type [" + type.getName() + "]: " + e.getMessage(), e);
        }
    }
122856
public static <T> Format<T> newCSVFormat(Class<T> beanType) {
    return new CSVFormat<T>(beanType);
  }
1056193
@Override
    public <T> T addBean(Class<T> type) {
        Bean    beanAnnotation = type.getAnnotation(Bean.class);
        boolean isSingleton    = null == beanAnnotation || beanAnnotation.singleton();
        if (isSingleton) {
            Object bean = put(type, true);
            return type.cast(bean);
        }
        return null;
    }
256954
@UsedByGeneratedCode
    public @Nonnull <T> T getBean(@Nullable BeanResolutionContext resolutionContext, @Nonnull Class<T> beanType) {
        ArgumentUtils.requireNonNull("beanType", beanType);
        return getBeanInternal(resolutionContext, beanType, null, true, true);
    }
329196
public static void registerBeanParser(BeanParser beanParser, Class<?>... supportClasses) {
    for (Class<?> supportClass : supportClasses) {
      typeBeanParserMap.put(supportClass, beanParser);
    }
  }
998139
private static TypeArgument parse(final Parser parser, final String definingClassName) throws ParseException {
        final char peek = parser.peek();
        if (peek == '*') {
            parser.expect('*');
            return new TypeArgument(Wildcard.ANY, null);
        } else if (peek == '+') {
            parser.expect('+');
            final ReferenceTypeSignature typeSignature = ReferenceTypeSignature.parseReferenceTypeSignature(parser,
                    definingClassName);
            if (typeSignature == null) {
                throw new ParseException(parser, "Missing '+' type bound");
            }
            return new TypeArgument(Wildcard.EXTENDS, typeSignature);
        } else if (peek == '-') {
            parser.expect('-');
            final ReferenceTypeSignature typeSignature = ReferenceTypeSignature.parseReferenceTypeSignature(parser,
                    definingClassName);
            if (typeSignature == null) {
                throw new ParseException(parser, "Missing '-' type bound");
            }
            return new TypeArgument(Wildcard.SUPER, typeSignature);
        } else {
            final ReferenceTypeSignature typeSignature = ReferenceTypeSignature.parseReferenceTypeSignature(parser,
                    definingClassName);
            if (typeSignature == null) {
                throw new ParseException(parser, "Missing type bound");
            }
            return new TypeArgument(Wildcard.NONE, typeSignature);
        }
    }
311427
public static AbstractShowParser newInstance(final DatabaseType dbType, final ShardingRule shardingRule, final LexerEngine lexerEngine) {
        switch (dbType) {
            case H2:
            case MySQL:
                return new MySQLShowParser(shardingRule, lexerEngine);
            default:
                throw new UnsupportedOperationException(String.format("Cannot support database [%s].", dbType));
        }
    }
1312294
public static KafkaProducer<String, byte[]> createKafkaProducer(ProducerType type,
            String bootstrapServers) {
        return createKafkaProducer(type, bootstrapServers, null);
    }