com.softicar.platform.common.core.java.classpath.AbstractJavaClasspathRoot Maven / Gradle / Ivy

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

The SoftiCAR Platform is a lightweight, Java-based library to create interactive business web applications.

There is a newer version: 50.0.0

package com.softicar.platform.common.core.java.classpath;

import com.softicar.platform.common.core.java.classes.analyzer.AnalyzedJavaClass;
import com.softicar.platform.common.core.java.classes.analyzer.JavaClassAnalyzer;
import com.softicar.platform.common.core.java.classes.name.JavaClassName;
import com.softicar.platform.common.io.classpath.file.IClasspathFile;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Optional;
import java.util.TreeMap;
import java.util.stream.Collectors;

abstract class AbstractJavaClasspathRoot implements IJavaClasspathRoot {

	private final File file;
	private final Map classMap;
	private boolean initialized;

	public AbstractJavaClasspathRoot(File file) {

		this.file = file;
		this.classMap = new TreeMap<>();
		this.initialized = false;
	}

	@Override
	public final File getFile() {

		return file;
	}

	@Override
	public final Collection getClassFiles() {

		return getAllFiles()//
			.stream()
			.filter(this::isClassFile)
			.collect(Collectors.toList());
	}

	@Override
	public final Collection getResourceFiles() {

		return getAllFiles()//
			.stream()
			.filter(this::isNotClassFile)
			.collect(Collectors.toList());
	}

	@Override
	public final Collection getAnalyzedClasses() {

		initializeIfNecessary();
		return Collections.unmodifiableCollection(classMap.values());
	}

	@Override
	public final Optional getAnalyzedClass(JavaClassName className) {

		initializeIfNecessary();
		return Optional.ofNullable(classMap.get(className));
	}

	@Override
	public final boolean isFolder() {

		return file.isDirectory();
	}

	@Override
	public final boolean isJar() {

		return !file.isDirectory() && file.getName().endsWith(".jar");
	}

	// ------------------------------ private ------------------------------ //

	private boolean isClassFile(IClasspathFile file) {

		return file.getName().endsWith(".class");
	}

	private boolean isNotClassFile(IClasspathFile file) {

		return !isClassFile(file);
	}

	private synchronized void initializeIfNecessary() {

		if (!initialized) {
			analyzeClasses().forEach(javaClass -> classMap.put(javaClass.getClassName(), javaClass));
			this.initialized = true;
		}
	}

	private Collection analyzeClasses() {

		return getClassFiles()//
			.stream()
			.map(this::analyzeClass)
			.collect(Collectors.toList());
	}

	private AnalyzedJavaClass analyzeClass(IClasspathFile file) {

		try {
			return new JavaClassAnalyzer(file::getInputStream).analyze();
		} catch (Exception exception) {
			System.err.printf("failed: %s\n", file.getName());
			throw exception;
		}
	}
}