one.xingyi.optics.annotations.serialise.IAnnotationProcessorLoader Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of rawprocessors Show documentation
There is a newer version: 1.5.9
package one.xingyi.optics.annotations.serialise;

import lombok.*;
import one.xingyi.optics.annotations.processors.PackageAndClass;
import one.xingyi.optics.annotations.interfaces.IFunctionWithException;

import javax.tools.FileObject;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public interface IAnnotationProcessorLoader {

    To load(From from) throws IOException;
}

@EqualsAndHashCode
@Getter
@ToString
@RequiredArgsConstructor
class AnnotationProcessorLoader implements IAnnotationProcessorLoader {

    private final Function fromToClassName;
    private final IFunctionWithException classNameToFileObject;
    private final BiFunction parser;


    @Override
    public T load(From from) throws IOException {
        var fileObject = classNameToFileObject.apply(fromToClassName.apply(from));
        var file = new File(fileObject.toUri());

        try (var reader = new FileReader(file)) {
            var bufferedReader = new BufferedReader(reader);
            return parser.apply(from, bufferedReader.lines().collect(Collectors.joining("\n")));
        }
    }
}

@EqualsAndHashCode
@Getter
@ToString
@RequiredArgsConstructor
class CachedAnnotationProcessorLoader implements IAnnotationProcessorLoader {

    private final IAnnotationProcessorLoader loader;
    private final ConcurrentHashMap cache;
    private final Function fromToClassName;

    @Override
    public T load(From from) throws IOException {
        var className = fromToClassName.apply(from);
        if (cache.containsKey(className)) return cache.get(className);
        synchronized (cache) {
            //double check locking pattern
            if (cache.containsKey(className)) return cache.get(className);
            var t = loader.load(from);
            cache.put(className, t);
            return t;
        }
    }
}

@EqualsAndHashCode
@Getter
@ToString
@RequiredArgsConstructor
class DebuggingAnnotationProcessorLoader implements IAnnotationProcessorLoader {
    private final IAnnotationProcessorLoader loader;
    private final Predicate debugPredicate;
    private final Consumer logger;


    @Override
    public T load(From from) throws IOException {
        try {
            if (debugPredicate.test(from)) logger.accept("Loading " + from);
            T result = loader.load(from);
            if (debugPredicate.test(from)) logger.accept("Loaded " + result + " from " + from);
            return result;
        } catch (IOException | RuntimeException e) {
            logger.accept("Error loading " + from + " " + e.getMessage());
            throw e;
        }
    }
}