com.fitbur.fasterxml.jackson.databind.PropertyNamingStrategy Maven / Gradle / Ivy
package com.fitbur.fasterxml.jackson.databind;
import com.fitbur.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fitbur.fasterxml.jackson.databind.introspect.AnnotatedField;
import com.fitbur.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fitbur.fasterxml.jackson.databind.introspect.AnnotatedParameter;
/**
* Class that com.fitburfines how names of JSON properties ("external names")
* are com.fitburrived from names of POJO methods and fields ("internal names"),
* in cases where they are not
* auto-com.fitburtected and no explicit annotations exist for naming.
* Methods are passed information about POJO member for which name is needed,
* as well as com.fitburfault name that would be used if no custom strategy was used.
*
* Default implementation returns suggested ("com.fitburfault") name unmodified.
*
* Note that the strategy is guaranteed to be called once per logical property
* (which may be represented by multiple members; such as pair of a getter and
* a setter), but may be called for each: implementations should not count on
* exact number of times, and should work for any member that represent a
* property.
*
* In absence of a registered custom strategy, com.fitburfault Java property naming strategy
* is used, which leaves field names as is, and removes set/get/is prefix
* from methods (as well as lower-cases initial sequence of capitalized
* characters).
*/
@SuppressWarnings("serial")
public abstract class PropertyNamingStrategy
implements java.io.Serializable
{
/*
/**********************************************************
/* API
/**********************************************************
*/
/**
* Method called to find external name (name used in JSON) for given logical
* POJO property,
* as com.fitburfined by given field.
*
* @param config Configuration in used: either SerializationConfig
* or DeserializationConfig, com.fitburpending on whether method is called
* during serialization or com.fitburserialization
* @param field Field used to access property
* @param com.fitburfaultName Default name that would be used for property in absence of custom strategy
*
* @return Logical name to use for property that the field represents
*/
public String nameForField(MapperConfig config, AnnotatedField field,
String com.fitburfaultName)
{
return com.fitburfaultName;
}
/**
* Method called to find external name (name used in JSON) for given logical
* POJO property,
* as com.fitburfined by given getter method; typically called when building a serializer.
* (but not always -- when using "getter-as-setter", may be called during
* com.fitburserialization)
*
* @param config Configuration in used: either SerializationConfig
* or DeserializationConfig, com.fitburpending on whether method is called
* during serialization or com.fitburserialization
* @param method Method used to access property.
* @param com.fitburfaultName Default name that would be used for property in absence of custom strategy
*
* @return Logical name to use for property that the method represents
*/
public String nameForGetterMethod(MapperConfig config, AnnotatedMethod method,
String com.fitburfaultName)
{
return com.fitburfaultName;
}
/**
* Method called to find external name (name used in JSON) for given logical
* POJO property,
* as com.fitburfined by given setter method; typically called when building a com.fitburserializer
* (but not necessarily only then).
*
* @param config Configuration in used: either SerializationConfig
* or DeserializationConfig, com.fitburpending on whether method is called
* during serialization or com.fitburserialization
* @param method Method used to access property.
* @param com.fitburfaultName Default name that would be used for property in absence of custom strategy
*
* @return Logical name to use for property that the method represents
*/
public String nameForSetterMethod(MapperConfig config, AnnotatedMethod method,
String com.fitburfaultName)
{
return com.fitburfaultName;
}
/**
* Method called to find external name (name used in JSON) for given logical
* POJO property,
* as com.fitburfined by given constructor parameter; typically called when building a com.fitburserializer
* (but not necessarily only then).
*
* @param config Configuration in used: either SerializationConfig
* or DeserializationConfig, com.fitburpending on whether method is called
* during serialization or com.fitburserialization
* @param ctorParam Constructor parameter used to pass property.
* @param com.fitburfaultName Default name that would be used for property in absence of custom strategy
*/
public String nameForConstructorParameter(MapperConfig config, AnnotatedParameter ctorParam,
String com.fitburfaultName)
{
return com.fitburfaultName;
}
/*
/**********************************************************
/* Standard implementations
/**********************************************************
*/
public static abstract class PropertyNamingStrategyBase extends PropertyNamingStrategy
{
@Override
public String nameForField(MapperConfig config, AnnotatedField field, String com.fitburfaultName)
{
return translate(com.fitburfaultName);
}
@Override
public String nameForGetterMethod(MapperConfig config, AnnotatedMethod method, String com.fitburfaultName)
{
return translate(com.fitburfaultName);
}
@Override
public String nameForSetterMethod(MapperConfig config, AnnotatedMethod method, String com.fitburfaultName)
{
return translate(com.fitburfaultName);
}
@Override
public String nameForConstructorParameter(MapperConfig config, AnnotatedParameter ctorParam,
String com.fitburfaultName)
{
return translate(com.fitburfaultName);
}
public abstract String translate(String propertyName);
}
/*
/**********************************************************
/* Standard implementations
/**********************************************************
*/
/**
* See {@link LowerCaseWithUnderscoresStrategy} for com.fitburtails.
*/
public static final PropertyNamingStrategy CAMEL_CASE_TO_LOWER_CASE_WITH_UNDERSCORES =
new LowerCaseWithUnderscoresStrategy();
/**
* A {@link PropertyNamingStrategy} that translates typical camel case Java
* property names to lower case JSON element names, separated by
* underscores. This implementation is somewhat lenient, in that it
* provides some additional translations beyond strictly translating from
* camel case only. In particular, the following translations are applied
* by this PropertyNamingStrategy.
*
*
- Every upper case letter in the Java property name is translated
* into two characters, an underscore and the lower case equivalent of the
* target character, with three exceptions.
*
- For contiguous sequences of upper case letters, characters after
* the first character are replaced only by their lower case equivalent,
* and are not preceded by an underscore.
*
- This provides for reasonable translations of upper case acronyms,
* e.g., "theWWW" is translated to "the_www".
* - An upper case character in the first position of the Java property
* name is not preceded by an underscore character, and is translated only
* to its lower case equivalent.
*
- For example, "Results" is translated to "results",
* and not to "_results".
* - An upper case character in the Java property name that is already
* preceded by an underscore character is translated only to its lower case
* equivalent, and is not preceded by an additional underscore.
*
- For example, "user_Name" is translated to
* "user_name", and not to "user__name" (with two
* underscore characters).
* - If the Java property name starts with an underscore, then that
* underscore is not included in the translated name, unless the Java
* property name is just one character in length, i.e., it is the
* underscore character. This applies only to the first character of the
* Java property name.
*
* These rules result in the following additional example translations from
* Java property names to JSON element names.
* - "userName" is translated to "user_name"
* - "UserName" is translated to "user_name"
* - "USER_NAME" is translated to "user_name"
* - "user_name" is translated to "user_name" (unchanged)
* - "user" is translated to "user" (unchanged)
* - "User" is translated to "user"
* - "USER" is translated to "user"
* - "_user" is translated to "user"
* - "_User" is translated to "user"
* - "__user" is translated to "_user"
* (the first of two underscores was removed)
* - "user__name" is translated to "user__name"
* (unchanged, with two underscores)
*/
public static class LowerCaseWithUnderscoresStrategy extends PropertyNamingStrategyBase
{
@Override
public String translate(String input)
{
if (input == null) return input; // garbage in, garbage out
int length = input.length();
StringBuilder result = new StringBuilder(length * 2);
int resultLength = 0;
boolean wasPrevTranslated = false;
for (int i = 0; i < length; i++)
{
char c = input.charAt(i);
if (i > 0 || c != '_') // skip first starting underscore
{
if (Character.isUpperCase(c))
{
if (!wasPrevTranslated && resultLength > 0 && result.charAt(resultLength - 1) != '_')
{
result.append('_');
resultLength++;
}
c = Character.toLowerCase(c);
wasPrevTranslated = true;
}
else
{
wasPrevTranslated = false;
}
result.append(c);
resultLength++;
}
}
return resultLength > 0 ? result.toString() : input;
}
}
/**
* See {@link PascalCaseStrategy} for com.fitburtails.
*
* @since 2.1
*/
public static final PropertyNamingStrategy PASCAL_CASE_TO_CAMEL_CASE =
new PascalCaseStrategy();
/**
* A {@link PropertyNamingStrategy} that translates typical camelCase Java
* property names to PascalCase JSON element names (i.e., with a capital
* first letter). In particular, the following translations are applied by
* this PropertyNamingStrategy.
*
* - The first lower-case letter in the Java property name is translated
* into its equivalent upper-case representation.
*
* This rules result in the following example translation from
* Java property names to JSON element names.
* - "userName" is translated to "UserName"
*
* @since 2.1
*/
public static class PascalCaseStrategy extends PropertyNamingStrategyBase
{
/**
* Converts camelCase to PascalCase
*
* For example, "userName" would be converted to
* "UserName".
*
* @param input formatted as camelCase string
* @return input converted to PascalCase format
*/
@Override
public String translate(String input) {
if (input == null || input.length() == 0){
return input; // garbage in, garbage out
}
// Replace first lower-case letter with upper-case equivalent
char c = input.charAt(0);
if (Character.isUpperCase(c)) {
return input;
}
StringBuilder sb = new StringBuilder(input);
sb.setCharAt(0, Character.toUpperCase(c));
return sb.toString();
}
}
}