@SuppressWarnings("unchecked")
 public static JsonSerializer<Object> getStdKeySerializer(JavaType keyType) {
   if (keyType == null) {
     return DEFAULT_KEY_SERIALIZER;
   }
   Class<?> cls = keyType.getRawClass();
   if (cls == String.class) {
     return DEFAULT_STRING_SERIALIZER;
   }
   if (cls == Object.class || cls.isPrimitive() || Number.class.isAssignableFrom(cls)) {
     return DEFAULT_KEY_SERIALIZER;
   }
   if (Date.class.isAssignableFrom(cls)) {
     return (JsonSerializer<Object>) DateKeySerializer.instance;
   }
   if (Calendar.class.isAssignableFrom(cls)) {
     return (JsonSerializer<Object>) CalendarKeySerializer.instance;
   }
   /* 14-Mar-2014, tatu: Should support @JsonValue, as per #47; but that
    *   requires extensive introspection, and passing in more information
    *   to this method.
    */
   // If no match, just use default one:
   return DEFAULT_KEY_SERIALIZER;
 }
 protected void assertType(Object ob, Class<?> expType) {
   if (ob == null) {
     fail("Expected an object of type " + expType.getName() + ", got null");
   }
   Class<?> cls = ob.getClass();
   if (!expType.isAssignableFrom(cls)) {
     fail("Expected type " + expType.getName() + ", got " + cls.getName());
   }
 }
  @SuppressWarnings("unchecked")
  public static <T> T convert(Context context, Class<T> type) {
    if (type.isAssignableFrom(Context.class)) {
      return (T) context;
    }
    if (type.isAssignableFrom(Map.class)) {
      return (T) context.keyValues();
    }
    if (isUrlEncodedForm(context)) {
      return convertValue(context.keyValues(), type);
    }

    String json;
    try {
      json = context.request().getContent();
    } catch (IOException e) {
      throw new IllegalArgumentException("Unable read request content", e);
    }

    return fromJson(json, type);
  }
 /**
  * Helper method for constructing exception to indicate that input JSON Number was not suitable
  * for deserializing into given target type.
  */
 public JsonMappingException weirdNumberException(Number value, Class<?> instClass, String msg) {
   return InvalidFormatException.from(
       _parser,
       "Can not construct instance of "
           + instClass.getName()
           + " from number value ("
           + _valueDesc()
           + "): "
           + msg,
       null,
       instClass);
 }
 /**
  * Helper method for constructing exception to indicate that given JSON Object field name was not
  * in format to be able to deserialize specified key type.
  */
 public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String msg) {
   return InvalidFormatException.from(
       _parser,
       "Can not construct Map key of type "
           + keyClass.getName()
           + " from String \""
           + _desc(keyValue)
           + "\": "
           + msg,
       keyValue,
       keyClass);
 }
 /**
  * Method that will construct an exception suitable for throwing when some String values are
  * acceptable, but the one encountered is not.
  *
  * @param value String value from input being deserialized
  * @param instClass Type that String should be deserialized into
  * @param msg Message that describes specific problem
  * @since 2.1
  */
 public JsonMappingException weirdStringException(String value, Class<?> instClass, String msg) {
   return InvalidFormatException.from(
       _parser,
       "Can not construct instance of "
           + instClass.getName()
           + " from String value '"
           + _valueDesc()
           + "': "
           + msg,
       value,
       instClass);
 }
示例#7
0
 public <T> T getWith(DrillConfig config, Class<T> c) {
   try {
     // logger.debug("Read tree {}", root);
     return config.getMapper().treeToValue(root, c);
   } catch (JsonProcessingException e) {
     throw new LogicalPlanParsingException(
         String.format(
             "Failure while trying to convert late bound json options to type of %s. Reference was originally located at line %d, column %d.",
             c.getCanonicalName(), location.getLineNr(), location.getColumnNr()),
         e);
   }
 }
 protected Server startServer(int port, Class<? extends Application> appClass) {
   Server server = new Server(port);
   final ContextHandlerCollection contexts = new ContextHandlerCollection();
   server.setHandler(contexts);
   ServletHolder jaxrs = new ServletHolder(ServletContainer.class);
   jaxrs.setInitParameter("javax.ws.rs.Application", appClass.getName());
   final ServletContextHandler mainHandler = new ServletContextHandler(contexts, "/", true, false);
   mainHandler.addServlet(jaxrs, "/*");
   server.setHandler(mainHandler);
   try {
     server.start();
   } catch (RuntimeException e) {
     throw e;
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
   return server;
 }
 protected String _calcName(Class<?> cls) {
   if (cls.isArray()) {
     return _calcName(cls.getComponentType()) + "[]";
   }
   return cls.getName();
 }
 public JsonMappingException endOfInputException(Class<?> instClass) {
   return JsonMappingException.from(
       _parser, "Unexpected end-of-input when trying to deserialize a " + instClass.getName());
 }
 public JsonMappingException instantiationException(Class<?> instClass, String msg) {
   return JsonMappingException.from(
       _parser, "Can not construct instance of " + instClass.getName() + ", problem: " + msg);
 }
 /**
  * Helper method for constructing instantiation exception for specified type, to indicate problem
  * with physically constructing instance of specified class (missing constructor, exception from
  * constructor)
  */
 public JsonMappingException instantiationException(Class<?> instClass, Throwable t) {
   return JsonMappingException.from(
       _parser,
       "Can not construct instance of " + instClass.getName() + ", problem: " + t.getMessage(),
       t);
 }