Removed the double foldering and started some seriouse work.

src/main/java/speiger/src/builder/base/ConditionedSegment.java

@@ -0,0 +1,89 @@
+package speiger.src.builder.base;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.regex.Pattern;
+
+import speiger.src.builder.conditions.ICondition;
+import speiger.src.builder.misc.Tuple;
+
+public class ConditionedSegment
+{
+	static final Pattern AND = Pattern.compile("(&&)");
+	static final Pattern OR = Pattern.compile("(||)");
+	
+	int index;
+	List<Tuple<ICondition, Segment>> segments = new ArrayList<>();
+	
+	public ConditionedSegment(int index)
+	{
+		this.index = index;
+	}
+	
+	public void addSegment(ICondition condition, Segment segment)
+	{
+		segments.add(new Tuple<>(condition, segment));
+	}
+	
+	public int build(Set<String> parsePool, StringBuilder builder, int baseIndex)
+	{
+		baseIndex += index;
+		int length = builder.length();
+		for(int i = 0,offset=0,m=segments.size();i<m;i++)
+		{
+			Tuple<ICondition, Segment> entry = segments.get(i);
+			if(entry.getKey().isValid(parsePool))
+			{
+				offset += entry.getValue().build(parsePool, builder, baseIndex+offset);
+				break;
+			}
+		}
+		return builder.length() - length;
+	}
+	
+	public static int parse(String currentLine, List<String> lines, int currentIndex, int startIndex, List<ConditionedSegment> segments) throws IllegalStateException
+	{
+		ConditionedSegment segment = new ConditionedSegment(startIndex);
+		ICondition condition = ICondition.parse(currentLine);
+		List<ConditionedSegment> childSegments = new ArrayList<>();
+		StringJoiner segmentText = new StringJoiner("\n", "\n", "");
+		for(int i = currentIndex+1;i<lines.size();i++)
+		{
+			String s = lines.get(i);
+			String trimmed = s.trim();
+			if(trimmed.startsWith("#"))
+			{
+				if(trimmed.startsWith("#else if"))
+				{
+					segment.addSegment(condition, new Segment(segmentText.toString(), childSegments));
+					condition = ICondition.parse(trimmed.substring(8).trim());
+					childSegments = new ArrayList<>();
+					segmentText = new StringJoiner("\n", "\n", "");
+				}
+				else if(trimmed.startsWith("#else"))
+				{
+					segment.addSegment(condition, new Segment(segmentText.toString(), childSegments));
+					condition = ICondition.ALWAYS_TRUE;
+					childSegments = new ArrayList<>();
+					segmentText = new StringJoiner("\n", "\n", "");
+				}
+				else if(trimmed.startsWith("#endif"))
+				{
+					segment.addSegment(condition, new Segment(segmentText.toString(), childSegments));
+					segments.add(segment);
+					return i - currentIndex;
+				}
+				else if(trimmed.startsWith("#if"))
+				{
+					i+= parse(trimmed.substring(3).trim(), lines, i, segmentText.length(), childSegments);
+				}
+				continue;
+			}
+			segmentText.add(s);
+		}
+		throw new IllegalStateException("Unclosed #If found!");
+	}
+	
+}

src/main/java/speiger/src/builder/base/Segment.java

@@ -0,0 +1,28 @@
+package speiger.src.builder.base;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public class Segment
+{
+	String text;
+	List<ConditionedSegment> segments = new ArrayList<>();
+	
+	public Segment(String text, List<ConditionedSegment> segments)
+	{
+		this.text = text;
+		this.segments = segments;
+	}
+	
+	public int build(Set<String> parsePool, StringBuilder builder, int index)
+	{
+		int length = builder.length();
+		builder.insert(index, text);
+		for(int i = 0,offset=0,m=segments.size();i<m;i++)
+		{
+			offset += segments.get(i).build(parsePool, builder, index+offset);
+		}
+		return builder.length() - length;
+	}
+}

src/main/java/speiger/src/builder/base/Template.java

@@ -0,0 +1,73 @@
+package speiger.src.builder.base;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.StringJoiner;
+import java.util.function.UnaryOperator;
+
+import speiger.src.builder.misc.FileUtils;
+
+public class Template
+{
+	String fileName;
+	String textFile;
+	List<ConditionedSegment> segments;
+	
+	public Template(String fileName, String textFile, List<ConditionedSegment> segments)
+	{
+		this.fileName = fileName;
+		this.textFile = textFile;
+		this.segments = segments;
+	}
+	
+	public String getFileName()
+	{
+		return fileName;
+	}
+	
+	public String build(Set<String> parsePool, List<UnaryOperator<String>> mappers)
+	{
+		StringBuilder builder = new StringBuilder(textFile);
+		for(int i = 0,offset=0,m=segments.size();i<m;i++)
+		{
+			offset += segments.get(i).build(parsePool, builder, offset);
+		}
+		String result = builder.toString();
+		for(int i = 0,m=mappers.size();i<m;i++)
+		{
+			result = mappers.get(i).apply(result);
+		}
+//		String s = "CLASS_TO_OBJ(\\([^)]+\\)|\\S)";
+		return result;
+	}
+	
+	public static Template parse(Path file) throws IOException
+	{
+		List<ConditionedSegment> segments = new ArrayList<ConditionedSegment>();
+		StringJoiner joiner = new StringJoiner("\n");
+		List<String> lines = Files.readAllLines(file);
+		for(int i = 0;i<lines.size();i++)
+		{
+			String s = lines.get(i);
+			String trimmed = s.trim();
+			if(trimmed.startsWith("#"))
+			{
+				if(trimmed.startsWith("#if"))
+				{
+					i += ConditionedSegment.parse(s.trim().substring(3).trim(), lines, i, joiner.length(), segments);
+					continue;					
+				}
+				else if(trimmed.startsWith("#symlink"))
+				{
+					return Template.parse(file.getParent().resolve(trimmed.substring(8).trim()));
+				}
+			}
+			joiner.add(s);
+		}
+		return new Template(FileUtils.getFileName(file.getFileName()), joiner.toString(), segments);
+	}
+}

src/main/java/speiger/src/builder/conditions/AndCondition.java

@@ -0,0 +1,33 @@
+package speiger.src.builder.conditions;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public class AndCondition implements ICondition
+{
+	List<ICondition> conditions = new ArrayList<>();
+	
+	public AndCondition(ICondition base)
+	{
+		conditions.add(base);
+	}
+	
+	public void addCondition(ICondition e)
+	{
+		conditions.add(e);
+	}
+	
+	@Override
+	public boolean isValid(Set<String> parsePool)
+	{
+		for(int i = 0,m=conditions.size();i<m;i++)
+		{
+			if(!conditions.get(i).isValid(parsePool))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+}

src/main/java/speiger/src/builder/conditions/FlagCondition.java

@@ -0,0 +1,21 @@
+package speiger.src.builder.conditions;
+
+import java.util.Set;
+
+public class FlagCondition implements ICondition
+{
+	String flag;
+	boolean inverted;
+	
+	public FlagCondition(String flag, boolean inverted)
+	{
+		this.flag = flag;
+		this.inverted = inverted;
+	}
+
+	@Override
+	public boolean isValid(Set<String> parsePool)
+	{
+		return parsePool.contains(flag) != inverted;
+	}
+}

src/main/java/speiger/src/builder/conditions/ICondition.java

@@ -0,0 +1,62 @@
+package speiger.src.builder.conditions;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public interface ICondition
+{
+	public static final ICondition ALWAYS_TRUE = T -> true;
+	
+	public boolean isValid(Set<String> parsePool);
+	
+	
+	public static ICondition parse(String condition)
+	{
+		String[] elements = condition.split(" ");
+		List<ICondition> conditions = new ArrayList<ICondition>();
+		for(int i = 0;i<elements.length;i++)
+		{
+			if(elements[i].equalsIgnoreCase("&&"))
+			{
+				if(i==elements.length-1)
+				{
+					continue;
+				}
+				if(condition.isEmpty())
+				{
+					conditions.add(new AndCondition(parseSimpleCondition(elements[++i])));
+				}
+				else
+				{
+					ICondition con = conditions.get(conditions.size() - 1);
+					if(con instanceof AndCondition)
+					{
+						((AndCondition)con).addCondition(parseSimpleCondition(elements[++i]));
+					}
+					else
+					{
+						AndCondition replacement = new AndCondition(con);
+						replacement.addCondition(parseSimpleCondition(elements[++i]));
+						conditions.set(conditions.size()-1, replacement);
+					}
+				}
+			}
+			else if(!elements[i].equalsIgnoreCase("||"))
+			{
+				conditions.add(parseSimpleCondition(elements[i]));
+			}
+		}
+		switch(conditions.size())
+		{
+			case 0: return ALWAYS_TRUE;
+			case 1: return conditions.get(0);
+			default: return new OrCondition(conditions);
+		}
+	}
+	
+	static ICondition parseSimpleCondition(String s)
+	{
+		return s.startsWith("!") ? new FlagCondition(s.substring(1), true) : new FlagCondition(s, false);
+	}
+}

src/main/java/speiger/src/builder/conditions/OrCondition.java

@@ -0,0 +1,27 @@
+package speiger.src.builder.conditions;
+
+import java.util.List;
+import java.util.Set;
+
+public class OrCondition implements ICondition
+{
+	List<ICondition> conditions;
+	
+	public OrCondition(List<ICondition> conditions)
+	{
+		this.conditions = conditions;
+	}
+
+	@Override
+	public boolean isValid(Set<String> parsePool)
+	{
+		for(int i = 0,m=conditions.size();i<m;i++)
+		{
+			if(conditions.get(i).isValid(parsePool))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+}

src/main/java/speiger/src/builder/example/GlobalVariables.java

@@ -0,0 +1,44 @@
+package speiger.src.builder.example;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.UnaryOperator;
+
+import speiger.src.builder.mappers.SimpleMapper;
+import speiger.src.builder.processor.TemplateProcess;
+
+public class GlobalVariables
+{
+	String fileName;
+	String folderName;
+	List<UnaryOperator<String>> operators = new ArrayList<>();
+	Set<String> flags = new LinkedHashSet<>();
+	
+	public GlobalVariables(String fileName, String folderName)
+	{
+		this.fileName = fileName;
+		this.folderName = folderName;
+	}
+	
+	public GlobalVariables createInitials(String classType, String keyType)
+	{
+		operators.add(new SimpleMapper("CLASS_TYPE", classType));
+		operators.add(new SimpleMapper("KEY_TYPE", keyType));
+		return this;
+	}
+	
+	public GlobalVariables createClassTypes(String fileType)
+	{
+		operators.add(new SimpleMapper("CONSUMER", fileType+"Consumer"));
+		return this;
+	}
+	
+	public TemplateProcess create(String fileName)
+	{
+		
+//		TemplateProcess process = new TemplateProcess(entry.getKey()+name+".java", Paths.get(""));
+		return null;
+	}
+}

src/main/java/speiger/src/builder/example/TestBuilder.java

@@ -0,0 +1,101 @@
+package speiger.src.builder.example;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+import speiger.src.builder.mappers.InjectMapper;
+import speiger.src.builder.mappers.SimpleMapper;
+import speiger.src.builder.processor.TemplateProcess;
+import speiger.src.builder.processor.TemplateProcessor;
+
+public class TestBuilder extends TemplateProcessor
+{
+	public static final String[] KEY_TYPE = new String[]{"byte", "short", "int", "long", "float", "double", "T"};
+	public static final String[] CLASS_TYPE = new String[]{"Byte", "Short", "Integer", "Long", "Float", "Double", "Object"};
+	public static final String[] FILE_TYPE = new String[]{"Byte", "Short", "Int", "Long", "Float", "Double", "Object"};
+	
+	List<GlobalVariables> varibles = new ArrayList<GlobalVariables>();
+	
+	public TestBuilder()
+	{
+		super(Paths.get("src\\main\\resources\\speiger\\assets\\collections\\templates\\"), Paths.get("src\\main\\java\\speiger\\src\\collections\\example\\"), Paths.get("src\\main\\resources\\speiger\\assets\\collections\\"));
+	}
+	
+	@Override
+	protected boolean isFileValid(Path fileName)
+	{
+		return true;
+	}
+	
+	@Override
+	protected boolean relativePackages()
+	{
+		return true;
+	}
+	
+	@Override
+	protected void init()
+	{
+		varibles.clear();
+		for(int i = 0,m=KEY_TYPE.length;i<m;i++)
+		{
+			GlobalVariables type = new GlobalVariables(FILE_TYPE[i]);
+			type.createInitials(CLASS_TYPE[i], KEY_TYPE[i]);
+			type.createClassTypes(FILE_TYPE[i]);
+			varibles.add(type);
+		}
+	}
+	
+	private List<UnaryOperator<String>> createForType(String lowercase, String upperCase, String classType, String consumer)
+	{
+		Files
+		List<UnaryOperator<String>> list = new ArrayList<>();
+		list.add(new SimpleMapper("JAVA_CONSUMER", "java.util.function."+consumer));
+		list.add(new SimpleMapper("CONSUMER", classType+"Consumer"));
+		list.add(new SimpleMapper("CLASS_TYPE", upperCase));
+		list.add(new SimpleMapper("KEY_TYPE", lowercase));
+		list.add(new InjectMapper("OBJ_TO_KEY(\\([^)]+\\)|\\S)", "%s."+lowercase+"Value()").removeBraces());
+		return list;
+	}
+
+	@Override
+	public void createProcesses(String name, Consumer<TemplateProcess> acceptor)
+	{
+		for(Entry<String, List<UnaryOperator<String>>> entry : data.entrySet())
+		{
+			TemplateProcess process = new TemplateProcess(entry.getKey()+name+".java", Paths.get(""));
+			process.addMappers(entry.getValue());
+			acceptor.accept(process);
+		}
+	}
+	
+	public static void main(String...args)
+	{
+		Path path = Paths.get("").toAbsolutePath();
+		System.out.println(path.toString());
+		for(int i = 0,m=path.getNameCount();i<m;i++)
+		{
+			System.out.println(path.getName(i).toString());
+		}
+//		try
+//		{
+//			new TestBuilder().process(true);
+//		}
+//		catch(InterruptedException e)
+//		{
+//			e.printStackTrace();
+//		}
+//		catch(IOException e)
+//		{
+//			e.printStackTrace();
+//		}
+	}
+	
+	
+}

src/main/java/speiger/src/builder/mappers/InjectMapper.java

@@ -0,0 +1,44 @@
+package speiger.src.builder.mappers;
+
+import java.util.function.UnaryOperator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class InjectMapper implements UnaryOperator<String>
+{
+	Pattern pattern;
+	String replacement;
+	boolean removeBraces;
+	
+	public InjectMapper(String pattern, String replacement)
+	{
+		this.pattern = Pattern.compile(pattern);
+		this.replacement = replacement;
+	}
+	
+	public InjectMapper removeBraces()
+	{
+		removeBraces = true;
+		return this;
+	}
+	
+	@Override
+	public String apply(String t)
+	{
+		Matcher matcher = pattern.matcher(t);
+		if(matcher.find())
+		{
+			StringBuffer buffer = new StringBuffer();			
+            do { matcher.appendReplacement(buffer, String.format(replacement, getString(matcher.group(1))));
+            } while (matcher.find());
+            matcher.appendTail(buffer);
+            return buffer.toString();
+		}
+		return t;
+	}
+	
+	private String getString(String s)
+	{
+		return removeBraces ? s.substring(1, s.length() - 1) : s;
+	}
+}

src/main/java/speiger/src/builder/mappers/SimpleMapper.java

@@ -0,0 +1,22 @@
+package speiger.src.builder.mappers;
+
+import java.util.function.UnaryOperator;
+import java.util.regex.Pattern;
+
+public class SimpleMapper implements UnaryOperator<String>
+{
+	Pattern pattern;
+	String replacement;
+
+	public SimpleMapper(String pattern, String replacement)
+	{
+		this.pattern = Pattern.compile(pattern);
+		this.replacement = replacement;
+	}
+	
+	@Override
+	public String apply(String t)
+	{
+		return pattern.matcher(t).replaceAll(replacement);
+	}
+}

src/main/java/speiger/src/builder/misc/FileUtils.java

@@ -0,0 +1,90 @@
+package speiger.src.builder.misc;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.security.MessageDigest;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class FileUtils
+{
+	public static boolean isValid(Path path, Map<String, String> existing)
+	{
+		String s = existing.get(getFileName(path));
+		return s == null || !s.equals(FileUtils.getMD5String(path));
+	}
+		
+	public static Map<String, String> loadMappings(Path dataFolder) throws IOException
+	{
+		Map<String, String> result = new LinkedHashMap<>();
+		dataFolder = dataFolder.resolve("cache.bin");
+		if(Files.notExists(dataFolder))
+		{
+			return result;
+		}
+		for(String s : Files.readAllLines(dataFolder))
+		{
+			String[] array = s.split("=");
+			if(array.length == 2)
+			{
+				result.put(array[0], array[1]);
+			}
+		}
+		return result;
+	}
+	
+	public static void saveMappings(Map<String, String> mappings, Path dataFolder)
+	{
+		try(BufferedWriter writer = Files.newBufferedWriter(dataFolder.resolve("cache.bin"), StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.DSYNC))
+		{
+			for(Entry<String, String> entry : mappings.entrySet())
+			{
+				writer.write(entry.getKey()+"="+entry.getValue());
+				writer.newLine();
+			}
+			writer.flush();
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	
+	public static String getFileName(Path path)
+	{
+		String name = path.getFileName().toString();
+		int index = name.indexOf(".");
+		return index == -1 ? name : name.substring(0, index);
+	}
+	
+	public static String getMD5String(Path path)
+	{
+		try(InputStream stream = Files.newInputStream(path))
+		{
+			MessageDigest digest = MessageDigest.getInstance("MD5");
+			byte[] byteArray = new byte[2048];
+			int bytesCount = 0;
+			while((bytesCount = stream.read(byteArray)) != -1)
+			{
+				digest.update(byteArray, 0, bytesCount);
+			}
+			byte[] bytes = digest.digest();
+			StringBuilder sb = new StringBuilder();
+			for(int i = 0;i < bytes.length;i++)
+			{
+				sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
+			}
+			return sb.toString();
+		}
+		catch(Exception e)
+		{
+			return null;
+		}
+	}
+}

src/main/java/speiger/src/builder/misc/Tuple.java

@@ -0,0 +1,23 @@
+package speiger.src.builder.misc;
+
+public class Tuple<K, V>
+{
+	K key;
+	V value;
+	
+	public Tuple(K key, V value)
+	{
+		this.key = key;
+		this.value = value;
+	}
+	
+	public K getKey()
+	{
+		return key;
+	}
+	
+	public V getValue()
+	{
+		return value;
+	}
+}

src/main/java/speiger/src/builder/processor/BuildTask.java

@@ -0,0 +1,47 @@
+package speiger.src.builder.processor;
+
+import java.io.BufferedWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+
+import speiger.src.builder.base.Template;
+
+public class BuildTask implements Runnable
+{
+	Path basePath;
+	Template template;
+	TemplateProcess process;
+	
+	public BuildTask(Path basePath, Template template, TemplateProcess process)
+	{
+		this.basePath = basePath;
+		this.template = template;
+		this.process = process;
+	}
+	
+	@Override
+	public void run()
+	{
+		String s = template.build(process.parsePool, process.mappers);
+		Path path = basePath.resolve(process.path).resolve(process.fileName);
+		try
+		{
+			Files.createDirectories(path.getParent());			
+		}
+		catch(Exception e)
+		{
+		}
+		try(BufferedWriter writer = Files.newBufferedWriter(path, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE, StandardOpenOption.SYNC))
+		{
+			writer.write(s);
+			writer.flush();
+			System.out.println("Created: "+process.fileName);
+		}
+		catch(Exception e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+}

src/main/java/speiger/src/builder/processor/TemplateProcess.java

@@ -0,0 +1,37 @@
+package speiger.src.builder.processor;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.UnaryOperator;
+
+public class TemplateProcess
+{
+	UnaryOperator pathBuilder;
+	String fileName;
+	Set<String> parsePool = new HashSet<>();
+	List<UnaryOperator<String>> mappers = new ArrayList<>();
+	
+	public TemplateProcess(String fileName)
+	{
+		this.fileName = fileName;
+	}
+	
+	public void addFlags(String...flags)
+	{
+		parsePool.addAll(Arrays.asList(flags));
+	}
+	
+	public void addMapper(UnaryOperator<String> mapper)
+	{
+		mappers.add(mapper);
+	}
+	
+	public void addMappers(Collection<UnaryOperator<String>> mappers)
+	{
+		this.mappers.addAll(mappers);
+	}
+}

src/main/java/speiger/src/builder/processor/TemplateProcessor.java

@@ -0,0 +1,90 @@
+package speiger.src.builder.processor;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import speiger.src.builder.base.Template;
+import speiger.src.builder.misc.FileUtils;
+
+public abstract class TemplateProcessor
+{
+	Path sourceFolder;
+	Path outputFolder;
+	Path dataFolder;
+	boolean init = false;
+	
+	
+	public TemplateProcessor(Path sourceFolder, Path outputFolder, Path dataFolder)
+	{
+		this.sourceFolder = sourceFolder;
+		this.outputFolder = outputFolder;
+		this.dataFolder = dataFolder;
+	}
+	
+	protected abstract void init();
+	
+	protected abstract boolean isFileValid(Path fileName);
+	
+	public abstract void createProcesses(String fileName, Consumer<TemplateProcess> process);
+	
+	protected abstract boolean relativePackages();
+	
+	public boolean process(boolean force) throws IOException, InterruptedException
+	{
+		if(!init)
+		{
+			init = true;
+			init();
+		}
+		Map<String, String> existing = FileUtils.loadMappings(dataFolder);
+		List<Path> pathsLeft = Files.walk(sourceFolder).filter(Files::isRegularFile).filter(T -> isFileValid(T.getFileName())).filter(T -> force || FileUtils.isValid(T, existing)).collect(Collectors.toList());
+		if(pathsLeft.isEmpty() && !force)
+		{
+			System.out.println("Nothing has changed");
+			return false;
+		}
+		final boolean relative = relativePackages();
+		ThreadPoolExecutor service = (ThreadPoolExecutor)Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+		service.setKeepAliveTime(10, TimeUnit.MILLISECONDS);
+		service.allowCoreThreadTimeOut(true);
+		service.submit(() -> {
+			for(int i = 0,m=pathsLeft.size();i<m;i++)
+			{
+				Path path = pathsLeft.get(i);
+				try
+				{
+					Template template = Template.parse(path);
+					createProcesses(FileUtils.getFileName(path), T -> service.execute(new BuildTask(relative ? outputFolder.resolve(sourceFolder.relativize(path).getParent()) : outputFolder, template, T)));
+				}
+				catch(Exception e) 
+				{ 
+					e.printStackTrace();
+					continue; 
+				}
+			}
+		});
+		long start = System.currentTimeMillis();
+		System.out.println("Started Tasks");
+		for(int i = 0,m=pathsLeft.size();i<m;i++)
+		{
+			Path path = pathsLeft.get(i);
+			existing.put(FileUtils.getFileName(path), FileUtils.getMD5String(path));
+		}
+		while(service.getActiveCount() > 0)
+		{
+			Thread.sleep(10);
+		}
+		System.out.println("Finished Tasks: "+(System.currentTimeMillis() - start)+"ms");
+		FileUtils.saveMappings(existing, dataFolder);
+		System.out.print("Saved Changes");
+		return true;
+	}
+}

src/main/java/speiger/src/collections/.gitignore

@@ -0,0 +1 @@
+/example/

src/main/resources/speiger/assets/collections/cache.bin

@@ -0,0 +1,2 @@
+List=8346cdbb0624aa07f1c54d00f765cbd5
+Consumer=e0112061d850a9ea6049cfe6571e2750

src/main/resources/speiger/assets/collections/templates/functions/Consumer.template

@@ -0,0 +1,22 @@
+package speiger.src.collections.example.functions;
+
+import java.util.Objects;
+import java.util.function.Consumer;
+
+public interface CONSUMER extends Consumer<CLASS_TYPE>, JAVA_CONSUMER
+{	
+	void accept(KEY_TYPE t);
+	
+	default void accept(CLASS_TYPE t) { accept(OBJ_TO_KEY(t)); }
+	
+	@Override
+	default CONSUMER andThen(Consumer<? super CLASS_TYPE> after) {
+		Objects.requireNonNull(after);
+		return T -> {accept(T); after.accept(T);};
+	}
+	
+	default CONSUMER andThen(CONSUMER after) {
+		Objects.requireNonNull(after);
+		return T -> {accept(T); after.accept(T);};
+	}
+}