com.google.gson.FieldNamingStrategy Java Examples

@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
  // Check if we can deal with the given type
  if (!IUnknownPropertiesConsumer.class.isAssignableFrom(typeToken.getRawType())) {
    return null;
  }
  // If we can, we should get the backing class to fetch its fields from
  @SuppressWarnings("unchecked")
  final Class<IUnknownPropertiesConsumer> rawType =
      (Class<IUnknownPropertiesConsumer>) typeToken.getRawType();
  @SuppressWarnings("unchecked")
  final TypeAdapter<IUnknownPropertiesConsumer> delegateTypeAdapter =
      (TypeAdapter<IUnknownPropertiesConsumer>) gson.getDelegateAdapter(this, typeToken);
  // Excluder is necessary to check if the field can be processed
  // Basically it's not required, but it makes the check more complete
  final Excluder excluder = gson.excluder();
  // This is crucial to map fields and JSON object properties since Gson supports name remapping
  final FieldNamingStrategy fieldNamingStrategy = gson.fieldNamingStrategy();
  final TypeAdapter<IUnknownPropertiesConsumer> unknownPropertiesTypeAdapter =
      UnknownPropertiesTypeAdapter.create(
          rawType, delegateTypeAdapter, excluder, fieldNamingStrategy);
  @SuppressWarnings("unchecked")
  final TypeAdapter<T> castTypeAdapter = (TypeAdapter<T>) unknownPropertiesTypeAdapter;
  return castTypeAdapter;
}
 

private static Collection<String> getPropertyNames(
    final Class<?> clazz,
    final Excluder excluder,
    final FieldNamingStrategy fieldNamingStrategy) {
  final Collection<String> propertyNames = new ArrayList<>();
  // Class fields are declared per class so we have to traverse the whole hierarchy
  for (Class<?> i = clazz;
      i.getSuperclass() != null && i != Object.class;
      i = i.getSuperclass()) {
    for (final Field declaredField : i.getDeclaredFields()) {
      // If the class field is not excluded
      if (!excluder.excludeField(declaredField, false)) {
        // We can translate the field name to its property name counter-part
        final String propertyName = fieldNamingStrategy.translateName(declaredField);
        propertyNames.add(propertyName);
      }
    }
  }
  return propertyNames;
}
 

@Override
protected void print(ExportHelper helper, EventLookupRpcRequest request, List<EventInterface> events, int eventCookieFlags, EventMeetingSortBy sort, boolean asc) throws IOException {
	helper.setup("application/json", reference(), false);
	
   	Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new JsonSerializer<Date>() {
		@Override
		public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
			return new JsonPrimitive(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'").format(src));
		}
	})
	.setFieldNamingStrategy(new FieldNamingStrategy() {
		Pattern iPattern = Pattern.compile("i([A-Z])(.*)");
		@Override
		public String translateName(Field f) {
			Matcher matcher = iPattern.matcher(f.getName());
			if (matcher.matches())
				return matcher.group(1).toLowerCase() + matcher.group(2);
			else
				return f.getName();
		}
	})
	.setPrettyPrinting().create();
   	
   	helper.getWriter().write(gson.toJson(events));
}
 

private static <T extends IUnknownPropertiesConsumer> TypeAdapter<T> create(
    final Class<? super T> clazz,
    final TypeAdapter<T> typeAdapter,
    final Excluder excluder,
    final FieldNamingStrategy fieldNamingStrategy) {
  final Collection<String> propertyNames =
      getPropertyNames(clazz, excluder, fieldNamingStrategy);
  return new UnknownPropertiesTypeAdapter<>(typeAdapter, propertyNames);
}
 

protected LaReflectiveTypeAdapterFactory createReflectiveTypeAdapterFactory(Gson newGson, Object factory) {
    final ConstructorConstructor constructorConstructor = getConstructorConstructor(factory);
    final JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory = getJsonAdapterFactory(factory);
    final FieldNamingStrategy fieldNamingStrategy = newGson.fieldNamingStrategy();
    final Excluder excluder = newGson.excluder();
    return new LaReflectiveTypeAdapterFactory(constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory);
}
 

public LaReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor, FieldNamingStrategy fieldNamingPolicy,
        Excluder excluder, JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory) {
    this.constructorConstructor = constructorConstructor;
    this.fieldNamingPolicy = fieldNamingPolicy;
    this.excluder = excluder;
    this.jsonAdapterFactory = jsonAdapterFactory;
}
 

public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,
    FieldNamingStrategy fieldNamingPolicy, Excluder excluder,
    JsonAdapterAnnotationTypeAdapterFactory jsonAdapterFactory) {
  this.constructorConstructor = constructorConstructor;
  this.fieldNamingPolicy = fieldNamingPolicy;
  this.excluder = excluder;
  this.jsonAdapterFactory = jsonAdapterFactory;
}
 

public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor, FieldNamingStrategy fieldNamingPolicy, Excluder excluder) {
    this.constructorConstructor = constructorConstructor;
    this.fieldNamingPolicy = fieldNamingPolicy;
    this.excluder = excluder;
}
 

public Builder setFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {
    this.fieldNamingStrategy = fieldNamingStrategy;
    return this;
}
 

private boolean isDeserializableInSubType(String fieldName, FieldNamingStrategy namingStrategy, List<Class<?>> concreteSubTypes) {
    return concreteSubTypes.stream().anyMatch(impl -> ClassUtils.findField(impl, field -> namingStrategy.translateName(field).equals(fieldName)).isPresent());
}
 

public GsonFieldNamingStrategy(FieldNamingStrategy fallback, MessageBundle messageBundle) {
    this.fallback = fallback;
    this.messageBundle = messageBundle;
}
 

private GsonValueMapperFactory(Gson prototype, TypeInfoGenerator typeInfoGenerator, FieldNamingStrategy fieldNamingStrategy, List<Configurer> configurers) {
    this.prototype = prototype;
    this.fieldNamingStrategy = fieldNamingStrategy;
    this.typeInfoGenerator = Objects.requireNonNull(typeInfoGenerator);
    this.configurers = Objects.requireNonNull(configurers);
}
 

public Builder withFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {
    this.fieldNamingStrategy = fieldNamingStrategy;
    return this;
}
 

public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorconstructor, FieldNamingStrategy fieldnamingstrategy, Excluder excluder)
{
    a = constructorconstructor;
    b = fieldnamingstrategy;
    c = excluder;
}
 

public ReflectiveTypeAdapterFactory(ConstructorConstructor constructorConstructor,
    FieldNamingStrategy fieldNamingPolicy, Excluder excluder) {
  this.constructorConstructor = constructorConstructor;
  this.fieldNamingPolicy = fieldNamingPolicy;
  this.excluder = excluder;
}
 

static String getFieldName(FieldNamingStrategy fieldNamingPolicy, Field f) {
  SerializedName serializedName = f.getAnnotation(SerializedName.class);
  return serializedName == null ? fieldNamingPolicy.translateName(f) : serializedName.value();
}