net.java.ao.schema.AbstractFieldNameConverter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of activeobjects Show documentation
This is the full Active Objects library, if you don't know which one to use, you probably want this one.
There is a newer version: 6.1.1
/*
 * Copyright 2007 Daniel Spiewak
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at
 * 
 *	    http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.java.ao.schema;

import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import net.java.ao.Common;
import net.java.ao.RawEntity;

import java.lang.reflect.Method;
import java.util.List;

import static java.util.Objects.requireNonNull;


/**
 * An abstract implementation of {@link FieldNameConverter} which handles common
 * tasks for the name converter (i.e. relations annotations, accessor/mutator
 * annotations, etc).  For most tasks, custom field name converters should extend
 * this class, rather than directly implementing FieldNameConverter.
 *
 * @author Daniel Spiewak
 */
public abstract class AbstractFieldNameConverter implements FieldNameConverter, FieldNameProcessor {
    private final List fieldNameResolvers;

    /**
     * Default constructor implementing the default behaviour for active objects.
     *
     * @see
     */
    protected AbstractFieldNameConverter() {
        this(Lists.newArrayList(
                new RelationalFieldNameResolver(),
                new MutatorFieldNameResolver(),
                new AccessorFieldNameResolver(),
                new PrimaryKeyFieldNameResolver(),
                new GetterFieldNameResolver(),
                new SetterFieldNameResolver(),
                new IsAFieldNameResolver(),
                new NullFieldNameResolver()
        ));
    }

    protected AbstractFieldNameConverter(List fieldNameResolvers) {
        this.fieldNameResolvers = requireNonNull(fieldNameResolvers);
    }

    /**
     * Handles operations which should be common to all field name converters
     * such as overriding of the generated field name through annotations, etc.
     * This method also handles the converting through the Java Bean method
     * prefix convention (get/set/is), allowing the implementing class to only
     * concern itself with converting one String (from the method
     * name) into another.
     *
     * This method delegates the actual conversion logic to the
     * {@link #convertName(String)} method.  There is rarely a need
     * for subclasses to override this method.
     *
     * @param method The method for which a field name must be generated.
     * @return A valid database identifier to be used as the field name representative
     * of the method in question.
     * @see net.java.ao.schema.FieldNameConverter#getName(Method)
     */
    public final String getName(Method method) {
        return getNameInternal(method, PolyTypeHandler.STRAIGHT);
    }

    /**
     * Documentation on the {@link #getName(Method)} method.
     *
     * @return A valid database identifier to be used as the field name representative
     * of the method in question.
     * @see net.java.ao.schema.FieldNameConverter#getPolyTypeName(Method)
     */
    public final String getPolyTypeName(Method method) {
        return getNameInternal(method, PolyTypeHandler.POLY);
    }

    private String getNameInternal(final Method method, final PolyTypeHandler polyTypeHandler) {
        final FieldNameResolver fieldNameResolver = findFieldNameResolver(requireNonNull(method));
        final String resolved = fieldNameResolver.resolve(method);

        if (resolved == null) {
            return null;
        }

        if (!fieldNameResolver.transform()) {
            return resolved;
        }

        if (polyTypeHandler.equals(PolyTypeHandler.POLY)) {
            return convertName(polyTypeHandler.handle(resolved));
        } else {
            final EntityFieldNameHandler from = EntityFieldNameHandler.from(method);
            return convertName(from.handle(polyTypeHandler.handle(resolved)));
        }
    }

    private static enum PolyTypeHandler {
        STRAIGHT, POLY {
            @Override
            String handle(String s) {
                return s + "Type";
            }
        };

        String handle(String s) {
            return s;
        }
    }

    private static enum EntityFieldNameHandler {
        PRIMITIVE, ENTITY {
            @Override
            String handle(String s) {
                return s + "ID";
            }
        };

        String handle(String s) {
            return s;
        }

        static EntityFieldNameHandler from(Method m) {
            return from(isAttributeOfTypeEntity(m));
        }

        static EntityFieldNameHandler from(boolean isEntity) {
            return isEntity ? ENTITY : PRIMITIVE;
        }
    }


    private FieldNameResolver findFieldNameResolver(final Method method) {
        return Iterables.find(fieldNameResolvers, new Predicate() {
            public boolean apply(FieldNameResolver input) {
                return input.accept(method);
            }
        });
    }

    private static boolean isAttributeOfTypeEntity(Method method) {
        final Class attributeTypeFromMethod = Common.getAttributeTypeFromMethod(method);
        return attributeTypeFromMethod != null && RawEntity.class.isAssignableFrom(attributeTypeFromMethod);
    }

    public abstract String convertName(String name);
}