feat(parser): MethodParser rework

lib/src/main/java/net/tomatentum/cutin/MethodParser.java

@@ -1,5 +1,7 @@
 package net.tomatentum.cutin;
 
+import java.lang.reflect.Method;
+
 public interface MethodParser {
-	void parse();
+	Object parse(Method method, Object containingObject);
 }

lib/src/main/java/net/tomatentum/cutin/ReflectedMethodFactory.java

@@ -1,8 +1,9 @@
 package net.tomatentum.cutin;
 
 import java.lang.reflect.Method;
-import java.util.List;
+import java.util.HashMap;
 import java.util.Optional;
+import java.util.Set;
 
 import net.tomatentum.cutin.method.ReflectedMethod;
 
@@ -13,8 +14,22 @@ public interface ReflectedMethodFactory<I extends Object, C extends Object> {
 
     public interface Factory<I extends Object, C extends Object> {
 
-        Optional<ReflectedMethod<I, C>> produce(Method method, Object containingObject);
-        void addParser(ReflectedMethod<I, C> method, List<MethodParser> parser);
+        Optional<ReflectedMethod<I, C>> produce(Method method, Object containingObject, ParserResults parserResults);
+        void addParser(Set<MethodParser> parser);
+
+    }
+
+    public static class ParserResults extends HashMap<Class<? extends MethodParser>, Object> {
+
+        public static ParserResults create(Set<MethodParser> parser, Method method, Object containingObject) {
+            ParserResults results = new ParserResults();
+            for (MethodParser p : parser) {
+                results.put(p.getClass(), p.parse(method, containingObject));
+            }
+            return results;
+        }
+
+        private ParserResults() {}
 
     }
 }

lib/src/main/java/net/tomatentum/cutin/ReflectedMethodFactoryImpl.java

@@ -2,8 +2,10 @@ package net.tomatentum.cutin;
 
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -50,13 +52,10 @@ public class ReflectedMethodFactoryImpl<I extends Object, C extends Object> impl
     }
 
     private Optional<ReflectedMethod<I, C>> factoryProduce(Factory<I, C> factory, Method method, Object containingClass) {
-        List<MethodParser> parser = new ArrayList<>();
-        Optional<ReflectedMethod<I, C>> m = factory.produce(method, containingClass);
-        m.ifPresent(x -> {
-            factory.addParser(x, parser); 
-            parser.forEach(MethodParser::parse);
-        });
-        return m;
+        Set<MethodParser> parser = new HashSet<>();
+        factory.addParser(parser); 
+        ParserResults results = ParserResults.create(parser, method, containingClass);
+        return factory.produce(method, containingClass, results);
     }
     
 }