docs: protected Object toJavaType(FieldWithAnnotation<Facebook> fieldWithAnnotation, JsonObject jsonObject,
        String facebookFieldName) {
      Class<?> type = fieldWithAnnotation.getField().getType();
      JsonValue rawValue = jsonObject.get(facebookFieldName);
  
      // Short-circuit right off the bat if we've got a null value.
      if (rawValue.isNull()) {
        return null;
      }
  
      if (String.class.equals(type)) {
        /*
         * Special handling here for better error checking.
         *
         * Since {@code JsonObject.getString()} will return literal JSON text even if it's _not_ a JSON string, we check
         * the marshaled type and bail if needed. For example, calling {@code JsonObject.getString("results")} on the
         * below JSON...
         *
         * <code> { "results":[ {"name":"Mark Allen"} ] } </code>
         *
         * ... would return the string {@code "[{"name":"Mark Allen"}]"} instead of throwing an error. So we throw the
         * error ourselves.
         *
         * Per Antonello Naccarato, sometimes FB will return an empty JSON array instead of an empty string. Look for that
         * here.
         */
        if (rawValue.isArray() && rawValue.asArray().isEmpty()) {
          MAPPER_LOGGER.trace("Coercing an empty JSON array to an empty string for {}", fieldWithAnnotation);
  
          return "";
        }
  
        /*
         * If the user wants a string, _always_ give her a string.
         *
         * This is useful if, for example, you've got a @Facebook-annotated string field that you'd like to have a numeric
         * type shoved into.
         *
         * User beware: this will turn *anything* into a string, which might lead to results you don't expect.
         */
        return jsonHelper.getStringFrom(rawValue);
      }
  
      if (Integer.class.equals(type) || Integer.TYPE.equals(type)) {
        return jsonHelper.getIntegerFrom(rawValue);
      }
      if (Boolean.class.equals(type) || Boolean.TYPE.equals(type)) {
        return jsonHelper.getBooleanFrom(rawValue);
      }
      if (Long.class.equals(type) || Long.TYPE.equals(type)) {
        return jsonHelper.getLongFrom(rawValue);
      }
      if (Double.class.equals(type) || Double.TYPE.equals(type)) {
        return jsonHelper.getDoubleFrom(rawValue);
      }
      if (Float.class.equals(type) || Float.TYPE.equals(type)) {
        return jsonHelper.getFloatFrom(rawValue);
      }
      if (BigInteger.class.equals(type)) {
        return jsonHelper.getBigIntegerFrom(rawValue);
      }
      if (BigDecimal.class.equals(type)) {
        return jsonHelper.getBigDecimalFrom(rawValue);
      }
      if (List.class.equals(type)) {
        return toJavaList(rawValue.toString(), getFirstParameterizedTypeArgument(fieldWithAnnotation.getField()));
      }
      if (Map.class.equals(type)) {
        return convertJsonObjectToMap(rawValue.toString(), fieldWithAnnotation.getField());
      }
  
      if (type.isEnum()) {
        Class<? extends Enum> enumType = type.asSubclass(Enum.class);
        try {
          return Enum.valueOf(enumType, rawValue.asString());
        } catch (IllegalArgumentException iae) {
          MAPPER_LOGGER.debug("Cannot map string {} to enum {}, try fallback toUpperString next...", rawValue.asString(),
            enumType.getName());
        }
        try {
          return Enum.valueOf(enumType, rawValue.asString().toUpperCase());
        } catch (IllegalArgumentException iae) {
          MAPPER_LOGGER.debug("Mapping string {} to enum {} not possible", rawValue.asString(), enumType.getName());
        }
      }
  
      if (Date.class.equals(type)) {
        return DateUtils.toDateFromLongFormat(jsonHelper.getStringFrom(rawValue));
      }
  
      String rawValueAsString = jsonHelper.getStringFrom(rawValue);
  
      // Hack for issue #76 where FB will sometimes return a Post's Comments as
      // "[]" instead of an object type (wtf)F
      if (Comments.class.isAssignableFrom(type) && rawValue instanceof JsonArray) {
        MAPPER_LOGGER.debug(
          "Encountered comment array '{}' but expected a {} object instead.  Working around that by coercing "
              + "into an empty {} instance...",
          rawValueAsString, Comments.class.getSimpleName(), Comments.class.getSimpleName());
  
        JsonObject workaroundJsonObject = new JsonObject();
        workaroundJsonObject.add("total_count", 0);
        workaroundJsonObject.add("data", new JsonArray());
        rawValueAsString = workaroundJsonObject.toString();
      }
  
      // Some other type - recurse into it
      return toJavaObject(rawValueAsString, type);
    }