com.fasterxml.jackson.databind.EnumNamingStrategies Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of redisson-all Show documentation

Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC

There is a newer version: 3.40.2

Show newest version

package com.fasterxml.jackson.databind;

/**
 * A container class for implementations of the {@link EnumNamingStrategy} interface.
 *
 * @since 2.15
 */
public class EnumNamingStrategies
{
    private EnumNamingStrategies() {}

    /**
     * 
     * An implementation of {@link EnumNamingStrategy} that converts enum names in the typical upper
     * snake case format to camel case format. This implementation follows three rules
     * described below.
     *
     * 

     * converts any character preceded by an underscore into upper case character,
     * regardless of its original case (upper or lower).
     * converts any character NOT preceded by an underscore into a lower case character,
     * regardless of its original case (upper or lower).
     * converts contiguous sequence of underscores into a single underscore.
     * 
     *
     * WARNING: Naming conversion conflicts caused by underscore usage should be handled by client.
     * e.g. Both PEANUT_BUTTER, PEANUT__BUTTER are converted into "peanutButter".
     * And "peanutButter" will be deserialized into enum with smaller Enum.ordinal() value.
     *
     * 
     * These rules result in the following example conversions from upper snakecase names
     * to camelcase names.
     * 

     * "USER_NAME" is converted into "userName"
     * "USER______NAME" is converted into "userName"
     * "USERNAME" is converted into "username"
     * "User__Name" is converted into "userName"
     * "_user_name" is converted into "UserName"
     * "_user_name_s" is converted into "UserNameS"
     * "__Username" is converted into "Username"
     * "__username" is converted into "Username"
     * "username" is converted into "username"
     * "Username" is converted into "username"
     * 
     *
     * @since 2.15
     */
    public static class CamelCaseStrategy implements EnumNamingStrategy
    {
        /**
         * An instance of {@link CamelCaseStrategy} for reuse.
         *
         * @since 2.15
         */
        public static final CamelCaseStrategy INSTANCE = new CamelCaseStrategy();

        /**
         * @since 2.15
         */
        @Override
        public String convertEnumToExternalName(String enumName) {
            if (enumName == null) {
                return null;
            }

            final String UNDERSCORE = "_";
            StringBuilder out = null;
            int iterationCnt = 0;
            int lastSeparatorIdx = -1;

            do {
                lastSeparatorIdx = indexIn(enumName, lastSeparatorIdx + 1);
                if (lastSeparatorIdx != -1) {
                    if (iterationCnt == 0) {
                        out = new StringBuilder(enumName.length() + 4 * UNDERSCORE.length());
                        out.append(toLowerCase(enumName.substring(iterationCnt, lastSeparatorIdx)));
                    } else {
                        out.append(normalizeWord(enumName.substring(iterationCnt, lastSeparatorIdx)));
                    }
                    iterationCnt = lastSeparatorIdx + UNDERSCORE.length();
                }
            } while (lastSeparatorIdx != -1);

            if (iterationCnt == 0) {
                return toLowerCase(enumName);
            }
            out.append(normalizeWord(enumName.substring(iterationCnt)));
            return out.toString();
        }

        private static int indexIn(CharSequence sequence, int start) {
            int length = sequence.length();
            for (int i = start; i < length; i++) {
                if ('_' == sequence.charAt(i)) {
                    return i;
                }
            }
            return -1;
        }

        private static String normalizeWord(String word) {
            int length = word.length();
            if (length == 0) {
                return word;
            }
            return new StringBuilder(length)
                    .append(charToUpperCaseIfLower(word.charAt(0)))
                    .append(toLowerCase(word.substring(1)))
                    .toString();
        }

        private static String toLowerCase(String string) {
            int length = string.length();
            StringBuilder builder = new StringBuilder(length);
            for (int i = 0; i < length; i++) {
                builder.append(charToLowerCaseIfUpper(string.charAt(i)));
            }
            return builder.toString();
        }

        private static char charToUpperCaseIfLower(char c) {
            return Character.isLowerCase(c) ? Character.toUpperCase(c) : c;
        }

        private static char charToLowerCaseIfUpper(char c) {
            return Character.isUpperCase(c) ? Character.toLowerCase(c) : c;
        }
    }
}