reflection: method

assira/src/main/java/net/ranides/assira/reflection/IClass.java

@@ -65,5 +65,19 @@ public interface IClass extends IElement, Comparable<IClass> {
     Class<?> reflective();
     
     //java.lang.reflect.Type type();
+	
+	/**
+	 * Checks if {@code this} is superclass of {@code type} (or equals)
+	 * @param type
+	 * @return 
+	 */
+	boolean issuper(IClass type);
+	
+	/**
+	 * Checks if {@code this} is a subclass of {@code type} (or equals)
+	 * @param type
+	 * @return 
+	 */
+	boolean issubclass(IClass type);
     
 }

assira/src/main/java/net/ranides/assira/reflection/IClasses.java

@@ -8,12 +8,31 @@ package net.ranides.assira.reflection;
 
 import java.lang.annotation.Annotation;
 import java.util.function.Predicate;
+import net.ranides.assira.reflection.impl.IClassFactory;
 
 /**
  *
  * @author Ranides Atterwim <ranides@gmail.com>
  */
 public interface IClasses extends IElements<IClass> {
+	
+	/**
+     * Collect information using java.reflection API
+     * @param type
+     * @return 
+     */
+    static IClasses typeinfo(Class<?>... types) {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * Collect information using ASM bytecode analyzer
+     * @param type
+     * @return 
+     */
+    static IClasses codeinfo(Class<?>... types) {
+        throw new UnsupportedOperationException();
+    }
     
     IClasses require(Predicate<? super IClass> predicate);
     
@@ -56,5 +75,12 @@ public interface IClasses extends IElements<IClass> {
     IClasses outer();
     
     IClasses inner();
+	
+	// some predicates
+	
+	boolean issuper(IClasses types);
+
+	boolean issubclass(IClasses types);
+
             
 }

assira/src/main/java/net/ranides/assira/reflection/IElements.java

@@ -8,6 +8,7 @@ package net.ranides.assira.reflection;
 
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collector;
 import java.util.stream.Stream;

assira/src/main/java/net/ranides/assira/reflection/IMethods.java

@@ -7,7 +7,6 @@
 package net.ranides.assira.reflection;
 
 import java.lang.annotation.Annotation;
-import java.util.Collection;
 import java.util.function.Predicate;
 
 /**
@@ -16,7 +15,7 @@ import java.util.function.Predicate;
  */
 public interface IMethods extends IElements<IMethod> {
     
-    IMethods require(Predicate<? super IField> predicate);
+    IMethods require(Predicate<? super IMethod> predicate);
     
     IMethods require(IAnnotations annotations);
     
@@ -26,11 +25,11 @@ public interface IMethods extends IElements<IMethod> {
     
     IMethods require(IClass returns);
     
-    IMethods require(IArguments params);
+    IMethods require(IArguments arguments);
     
-    IMethods require(IClasses params);
+    IMethods require(IClasses arguments);
     
-    IMethods discard(Predicate<? super IField> predicate);
+    IMethods discard(Predicate<? super IMethod> predicate);
     
     IMethods discard(IAnnotations annotations);
     
@@ -40,11 +39,11 @@ public interface IMethods extends IElements<IMethod> {
     
     IMethods discard(IClass returns);
     
-    IMethods discard(IArguments params);
+    IMethods discard(IArguments arguments);
     
-    IMethods discard(IClasses params);
+    IMethods discard(IClasses arguments);
     
-    IMethods match(Object[] params);
+    IMethods match(Object[] arguments);
     
     // deep scan
     

assira/src/main/java/net/ranides/assira/reflection/impl/IMethodFactory.java

@@ -6,17 +6,9 @@
  */
 package net.ranides.assira.reflection.impl;
 
-import java.lang.invoke.MethodHandle;
 import java.lang.reflect.Method;
 import java.util.Optional;
-import java.util.Set;
-import java.util.function.Function;
-import net.ranides.assira.reflection.IAnnotations;
-import net.ranides.assira.reflection.IArguments;
-import net.ranides.assira.reflection.IAttribute;
-import net.ranides.assira.reflection.IClass;
 import net.ranides.assira.reflection.IMethod;
-import net.ranides.assira.reflection.IMethods;
 
 /**
  *
@@ -29,7 +21,7 @@ public final class IMethodFactory {
     }
     
     public static IMethod typeinfo(Method method) {
-        throw new UnsupportedOperationException("Not supported yet.");
+		return new RMethod(method);
     }
     
     public static IMethod codeinfo(Method method) {
@@ -77,83 +69,4 @@ public final class IMethodFactory {
         return codeinfo(method.get());
     }
 
-    private static class RFMethod implements IMethod {
-
-        @Override
-        public IMethods asList() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public IClass[] params() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public IClass returns() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public IArguments arguments() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public IClass parent() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Object call() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Object call(Object that) {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Object call(Object that, Object... arguments) {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Function<Object, Object[]> bind(Object that) {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Method reflective() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public MethodHandle handle() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public String name() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public Set<IAttribute> attributes() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public IAnnotations annotations() {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-
-        @Override
-        public int compareTo(IMethod o) {
-            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
-        }
-        
-    }
-
 }

assira/src/main/java/net/ranides/assira/reflection/impl/RMethod.java

@@ -0,0 +1,114 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.reflection.impl;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import net.ranides.assira.reflection.IAnnotations;
+import net.ranides.assira.reflection.IArguments;
+import net.ranides.assira.reflection.IAttribute;
+import net.ranides.assira.reflection.IClass;
+import net.ranides.assira.reflection.IMethod;
+import net.ranides.assira.reflection.IMethods;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class RMethod implements IMethod {
+	
+	private final Method method;
+
+	public RMethod(Method method) {
+		this.method = method;
+	}
+
+	@Override
+	public IMethods asList() {
+		return new RMethods(Arrays.<IMethod>asList(this).stream());
+	}
+
+	@Override
+	public IClass[] params() {
+//		method.getTypeParameters();
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public IClass returns() {
+//		return IClass.typeinfo(method.getReturnType());
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public IArguments arguments() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public IClass parent() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Object call() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Object call(Object that) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Object call(Object that, Object... arguments) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Function<Object, Object[]> bind(Object that) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Method reflective() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public MethodHandle handle() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public String name() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public Set<IAttribute> attributes() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public IAnnotations annotations() {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public int compareTo(IMethod o) {
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+	
+	
+
+}

assira/src/main/java/net/ranides/assira/reflection/impl/RMethods.java

@@ -0,0 +1,184 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+
+package net.ranides.assira.reflection.impl;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import net.ranides.assira.reflection.IAnnotations;
+import net.ranides.assira.reflection.IArguments;
+import net.ranides.assira.reflection.IAttribute;
+import net.ranides.assira.reflection.IClass;
+import net.ranides.assira.reflection.IClasses;
+import net.ranides.assira.reflection.IElement;
+import net.ranides.assira.reflection.IMethod;
+import net.ranides.assira.reflection.IMethods;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class RMethods implements IMethods {
+	
+	private Stream<IMethod> stream;
+
+	public RMethods(Stream<IMethod> stream) {
+		this.stream = stream;
+	}
+
+	@Override
+	public IMethods require(Predicate<? super IMethod> predicate) {
+		stream = stream.filter(predicate);
+		return this;
+	}
+
+	@Override
+	public IMethods require(IAnnotations req) {
+		return require(m -> {
+			Set<Annotation> set = m.annotations().stream().collect(Collectors.toSet());
+			return req.stream().allMatch(set::contains);
+		});
+	}
+
+	@Override
+	public IMethods require(Class<? extends Annotation> annotation) {
+		return require(m -> m.annotations().require(annotation).first().isPresent());
+	}
+
+	@Override
+	public IMethods require(IAttribute attribute) {
+		return require(m -> m.attributes().contains(attribute));
+	}
+
+	@Override
+	public IMethods require(IClass req) {
+		return require(m -> m.returns().issubclass(req));
+	}
+
+	@Override
+	public IMethods require(IArguments args) {
+		IClasses req = args.types();
+		return require(m -> m.arguments().types().issuper(req));
+	}
+
+	@Override
+	public IMethods require(IClasses req) {
+		return require(m -> m.arguments().types().equals(req));
+	}
+
+	@Override
+	public IMethods discard(Predicate<? super IMethod> predicate) {
+		return require(predicate.negate());
+	}
+
+	@Override
+	public IMethods discard(IAnnotations annotations) {
+		Set<Annotation> req = annotations.stream().collect(Collectors.toSet());
+		return require(m -> !m.annotations().stream().anyMatch(req::contains));
+	}
+
+	@Override
+	public IMethods discard(Class<? extends Annotation> annotation) {
+		return require(m -> !m.annotations().first(annotation).isPresent());
+	}
+
+	@Override
+	public IMethods discard(IAttribute attribute) {
+		return require(m -> !m.attributes().contains(attribute));
+	}
+
+	@Override
+	public IMethods discard(IClass returns) {
+		return require(m -> !m.returns().issubclass(returns));
+	}
+
+	@Override
+	public IMethods discard(IArguments args) {
+		IClasses req = args.types();
+		return require(m -> !m.arguments().types().issuper(req));
+	}
+
+	@Override
+	public IMethods discard(IClasses args) {
+		return require(m -> m.arguments().types().equals(args));
+	}
+
+	@Override
+	public IMethods match(Object[] args) {
+		IClasses types = IClasses.typeinfo(objects2class(args));
+		return require(m -> types.issubclass(m.arguments().types()));
+	}
+	
+	static Class<?>[] objects2class(Object... objects) {
+		Class<?>[] array = new Class<?>[objects.length];
+		for(int i=0; i<array.length; i++) {
+			Object o = objects[i];
+			array[i] = null == o ? null : objects[i].getClass();
+		}
+		return array;
+	}
+
+	@Override
+	public IClasses returns() {
+//		return new RClasses(stream().map(m ->returns()));
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public IClasses parent() {
+//		new RClasses(stream().map(m ->parent()));
+		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+	}
+
+	@Override
+	public int count() {
+		return (int)stream.count();
+	}
+
+	@Override
+	public <R> Stream<R> stream(Function<? super IMethod, ? extends R> mapper) {
+		return stream.map(mapper);
+	}
+
+	@Override
+	public Stream<IMethod> stream() {
+		return stream;
+	}
+
+	@Override
+	public <R> List<R> list(Function<? super IMethod, ? extends R> mapper) {
+		return stream.map(mapper).collect(Collectors.toList());
+	}
+
+	@Override
+	public List<IMethod> list() {
+		return stream.collect(Collectors.toList());
+	}
+
+	@Override
+	public <R, A> R collect(Collector<? super IMethod, A, R> collector) {
+		return stream.collect(collector);
+	}
+
+	@Override
+	public Optional<IMethod> first() {
+		return stream.findFirst();
+	}
+
+	@Override
+	public List<String> names() {
+		return stream.map(IElement::name).collect(Collectors.toList());
+	}
+
+}