com.tvd12.ezyfox.identifier.EzyIdEncapsulationBuilder Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of ezyfox-identifier Show documentation
The newest version!
package com.tvd12.ezyfox.identifier;

import com.tvd12.ezyfox.builder.EzyBuilder;
import com.tvd12.ezyfox.collect.Sets;
import com.tvd12.ezyfox.reflect.EzyReflection;
import com.tvd12.ezyfox.reflect.EzyReflectionProxy;
import com.tvd12.ezyfox.util.EzyHasIdEntity;

import java.lang.annotation.Annotation;
import java.util.HashSet;
import java.util.Set;

@SuppressWarnings({"rawtypes", "unchecked"})
public abstract class EzyIdEncapsulationBuilder<
    T, B extends EzyIdEncapsulationBuilder
    >
    implements EzyBuilder {

    protected final Set entityClasses;
    protected final Set packagesToScan;
    protected final Set> annotationClasses;

    public EzyIdEncapsulationBuilder() {
        this.packagesToScan = new HashSet<>();
        this.entityClasses = new HashSet<>();
        this.annotationClasses = getAnnotationClasses();
    }

    public B scan(String packageName) {
        packagesToScan.add(packageName);
        return (B) this;
    }

    public B scan(String... packageNames) {
        return scan(Sets.newHashSet(packageNames));
    }

    public B scan(Iterable packageNames) {
        for (String packageName : packageNames) {
            this.scan(packageName);
        }
        return (B) this;
    }

    public B addClass(Class clazz) {
        if (isHasIdClass(clazz) || isAnnotatedClass(clazz)) {
            this.entityClasses.add(clazz);
        }
        return (B) this;
    }

    public B addClasses(Class... classes) {
        return addClasses(Sets.newHashSet(classes));
    }

    public B addClasses(Iterable classes) {
        for (Class clazz : classes) {
            this.addClass(clazz);
        }
        return (B) this;
    }

    public B addClasses(EzyReflection reflection) {
        Set> hasIdClasses = reflection
            .getExtendsClasses(EzyHasIdEntity.class);
        Set> annotatedClasses = new HashSet<>(
            reflection.getAnnotatedClasses(annotationClasses)
        );
        this.entityClasses.addAll(hasIdClasses);
        this.entityClasses.addAll(annotatedClasses);
        return (B) this;
    }

    @Override
    public T build() {
        preBuild();
        return newProduct();
    }

    protected abstract T newProduct();

    protected void preBuild() {
        scanAllPackages();
        parseEntityClasses();
    }

    protected abstract void parseEntityClasses();

    protected void scanAllPackages() {
        if (packagesToScan.isEmpty()) {
            return;
        }
        EzyReflection reflection = new EzyReflectionProxy(packagesToScan);
        addClasses(reflection);
    }

    protected boolean isHasIdClass(Class clazz) {
        return EzyHasIdEntity.class.isAssignableFrom(clazz);
    }

    protected boolean isAnnotatedClass(Class clazz) {
        for (Class annClass : annotationClasses) {
            if (clazz.isAnnotationPresent(annClass)) {
                return true;
            }
        }
        return false;
    }

    protected Set> getAnnotationClasses() {
        return new HashSet<>();
    }
}