Example usage for org.apache.commons.lang StringUtils uncapitalize

Introduction

In this page you can find the example usage for org.apache.commons.lang StringUtils uncapitalize.

Prototype

public static String uncapitalize(String str)

Source Link

Document

Uncapitalizes a String changing the first letter to title case as per Character#toLowerCase(char) .

Usage

From source file:org.gradle.model.internal.manage.schema.extraction.ModelSchemaExtractor.java

private <T> ModelProperty<T> extractManagedProperty(Class<?> type, Map<String, Method> methods,
        String getterName, ModelType<T> propertyType, List<String> handled) {
    String propertyNameCapitalized = getterName.substring(3);
    String propertyName = StringUtils.uncapitalize(propertyNameCapitalized);
    String setterName = "set" + propertyNameCapitalized;

    if (methods.containsKey(setterName)) {
        validateSetter(type, propertyType, methods.get(setterName));
        handled.add(setterName);/*  ww  w.  j a v a  2  s. com*/
        getModelSchema(type, propertyType.getConcreteClass(), propertyName);
        return new ModelProperty<T>(propertyName, propertyType, true);
    } else {
        final ModelSchema<T> modelSchema = getModelSchema(type, propertyType.getConcreteClass(), propertyName);
        return new ModelProperty<T>(propertyName, propertyType, true, new Factory<T>() {
            public T create() {
                ManagedModelElement<T> managedModelElement = new ManagedModelElement<T>(modelSchema);
                return managedElementFactory.create(managedModelElement);
            }
        });
    }
}

From source file:org.gradle.model.internal.manage.schema.ModelSchemaExtractor.java

public <T> ModelSchema<T> extract(Class<T> type) throws InvalidManagedModelElementTypeException {
    validateType(type);//from  w  ww .  ja va2s. c  om

    List<Method> methodList = Arrays.asList(type.getDeclaredMethods());
    if (methodList.isEmpty()) {
        return new ModelSchema<T>(type, Collections.<ModelProperty<?>>emptyList());
    }

    List<ModelProperty<?>> properties = Lists.newLinkedList();

    Map<String, Method> methods = Maps.newHashMap();
    for (Method method : methodList) {
        String name = method.getName();
        if (methods.containsKey(name)) {
            throw invalidMethod(type, name, "overloaded methods are not supported");
        }
        methods.put(name, method);
    }

    List<String> methodNames = Lists.newLinkedList(methods.keySet());
    List<String> handled = Lists.newArrayList();

    for (ListIterator<String> iterator = methodNames.listIterator(); iterator.hasNext();) {
        String methodName = iterator.next();

        Method method = methods.get(methodName);
        if (methodName.startsWith("get") && !methodName.equals("get")) {
            if (method.getParameterTypes().length != 0) {
                throw invalidMethod(type, methodName, "getter methods cannot take parameters");
            }

            Class<?> returnType = method.getReturnType();
            if (!returnType.equals(String.class)) {
                throw invalidMethod(type, methodName, "only String properties are supported");
            }

            // hardcoded for now
            ModelType<String> propertyType = ModelType.of(String.class);

            Character getterPropertyNameFirstChar = methodName.charAt(3);
            if (!Character.isUpperCase(getterPropertyNameFirstChar)) {
                throw invalidMethod(type, methodName,
                        "the 4th character of the getter method name must be an uppercase character");
            }

            String propertyNameCapitalized = methodName.substring(3);
            String propertyName = StringUtils.uncapitalize(propertyNameCapitalized);
            String setterName = "set" + propertyNameCapitalized;

            if (!methods.containsKey(setterName)) {
                throw invalidMethod(type, methodName, "no corresponding setter for getter");
            }

            Method setter = methods.get(setterName);
            handled.add(setterName);

            if (!setter.getReturnType().equals(void.class)) {
                throw invalidMethod(type, setterName, "setter method must have void return type");
            }

            Type[] setterParameterTypes = setter.getGenericParameterTypes();
            if (setterParameterTypes.length != 1) {
                throw invalidMethod(type, setterName, "setter method must have exactly one parameter");
            }

            ModelType<?> setterType = ModelType.of(setterParameterTypes[0]);
            if (!setterType.equals(propertyType)) {
                throw invalidMethod(type, setterName,
                        "setter method param must be of exactly the same type as the getter returns (expected: "
                                + propertyType + ", found: " + setterType + ")");
            }

            properties.add(new ModelProperty<String>(propertyName, propertyType));
            iterator.remove();
        }
    }

    methodNames.removeAll(handled);

    // TODO - should call out valid getters without setters
    if (!methodNames.isEmpty()) {
        throw invalid(type, "only paired getter/setter methods are supported (invalid methods: ["
                + Joiner.on(", ").join(methodNames) + "])");
    }

    return new ModelSchema<T>(type, properties);
}

From source file:org.gradle.model.internal.manage.schema.store.ModelSchemaExtractor.java

private <T> ModelPropertyFactory<T> extractPropertyOfUnmanagedType(ModelType<?> type,
        Map<String, Method> methods, String getterName, final ModelType<T> propertyType, List<String> handled) {
    Class<?> boxedType = BOXED_REPLACEMENTS.get(propertyType);
    if (boxedType != null) {
        throw invalidMethod(type, getterName, String.format(
                "%s is not a supported property type, use %s instead", propertyType, boxedType.getName()));
    }//from www .  j  av a  2  s  .c om
    if (!isSupportedUnmanagedType(propertyType)) {
        String supportedTypes = Joiner.on(", ").join(SUPPORTED_UNMANAGED_TYPES);
        throw invalidMethod(type, getterName, String.format(
                "%s is not a supported property type, only managed and the following unmanaged types are supported: %s",
                propertyType, supportedTypes));
    }

    String propertyNameCapitalized = getterName.substring(3);
    final String propertyName = StringUtils.uncapitalize(propertyNameCapitalized);
    String setterName = "set" + propertyNameCapitalized;

    if (!methods.containsKey(setterName)) {
        throw invalidMethod(type, getterName, "no corresponding setter for getter");
    }

    validateSetter(type, propertyType, methods.get(setterName));
    handled.add(setterName);
    return new ModelPropertyFactory<T>() {
        public ModelProperty<T> create(ModelSchemaStore store) {
            return new ModelProperty<T>(propertyName, propertyType);
        }
    };
}

From source file:org.gradle.model.internal.manage.schema.store.ModelSchemaExtractor.java

private <T> ModelPropertyFactory<T> extractPropertyOfManagedType(ModelType<?> type, Map<String, Method> methods,
        String getterName, ModelType<T> propertyType, List<String> handled) {
    String propertyNameCapitalized = getterName.substring(3);
    String propertyName = StringUtils.uncapitalize(propertyNameCapitalized);
    String setterName = "set" + propertyNameCapitalized;

    if (methods.containsKey(setterName)) {
        validateSetter(type, propertyType, methods.get(setterName));
        handled.add(setterName);//from ww  w.  j a v a2 s .c  om
        return new ManagedModelReferencePropertyFactory<T>(type, propertyType, propertyName);
    } else {
        return new ManagedModelInstancePropertyFactory<T>(type, propertyType, propertyName);
    }
}

From source file:org.hako.dao.mapper.MethodSetter.java

/**
 * Create.//from www.j  a v  a 2  s . co m
 * 
 * @param setter
 */
public MethodSetter(Method setter) {
    super();
    this.setter = setter;
    this.propertyName = StringUtils.uncapitalize(setter.getName().substring(3));
}

From source file:org.hako.util.object.GetMethodGetter.java

public String getPropertyName() {
    return StringUtils.uncapitalize(method.getName().substring(3));
}

From source file:org.hako.util.object.IsMethodGetter.java

public String getPropertyName() {
    return StringUtils.uncapitalize(method.getName().substring(2));
}

From source file:org.isatools.isatab.mapping.attributes.AnnotationMappingHelper.java

public AnnotationMappingHelper(BIIObjectStore store, SectionInstance sectionInstance,
        Map<String, String> options, int fieldIndex) {
    super(store, sectionInstance, options, fieldIndex);
    this.annotationType = new AnnotationType(StringUtils.uncapitalize(getPropertyName()));
}

From source file:org.isatools.isatab.mapping.attributes.AnnotationMappingHelper.java

public AnnotationMappingHelper(BIIObjectStore store, SectionInstance sectionInstance, String fieldName,
        String propertyName, int fieldIndex) {
    super(store, sectionInstance, fieldName, propertyName, fieldIndex);
    this.annotationType = new AnnotationType(StringUtils.uncapitalize(propertyName));
}

From source file:org.jahia.bin.Action.java

public String getName() {
    return name != null ? name
            : StringUtils.uncapitalize(StringUtils.substringBeforeLast(getClass().getSimpleName(), "Action"));
}