Added NonInheritImplements.

This allows classes to declare that they implement a specific interface,
but does not strictly require that subclasses also implement this
interface as well (through inheritance). There is a custom compile check
as well, but in general, this requires using the Helper class as well to
correctly cast to the interface and check instanceof.

The use case imagined here is for serialization and/or cloning, where
you want some classes in the heirarchy to be serializable or cloneable,
but not necessarily subclasses of those classes.

Author: LadyCailin

pom.xml

@@ -461,6 +461,7 @@
 					<target>1.8</target>
 					<compilerArgs>
 						<arg>-XDignore.symbol.file</arg>
+						<arg>-parameters</arg>
 					</compilerArgs>
 					<fork>true</fork>
 					<optimize>true</optimize>

src/main/java/com/laytonsmith/PureUtilities/ClassLoading/Annotations/CacheAnnotations.java

@@ -51,6 +51,7 @@ public static void main(String[] args) throws Exception {
 		AnnotationChecks.checkForceImplementation();
 		AnnotationChecks.checkForTypeInTypeofClasses();
 		AnnotationChecks.verifyExhaustiveVisitors();
+		AnnotationChecks.verifyNonInheritImplements();
 
 		Implementation.setServerType(Implementation.Type.SHELL);
 		List<String> uhohs = new ArrayList<>();

src/main/java/com/laytonsmith/PureUtilities/ClassLoading/ClassMirror/AnnotationMirror.java

@@ -1,5 +1,6 @@
 package com.laytonsmith.PureUtilities.ClassLoading.ClassMirror;
 
+import com.laytonsmith.PureUtilities.ClassLoading.ClassDiscovery;
 import com.laytonsmith.PureUtilities.Common.ClassUtils;
 import com.laytonsmith.PureUtilities.Common.StringUtils;
 import java.io.Serializable;
@@ -56,6 +57,10 @@ public AnnotationMirror(Annotation annotation) {
 	 * actually loading the annotation class into memory. See {@link #getValueWithDefault} if you are ok with loading
 	 * the annotation class into memory. Null is returned if this value doesn't exist.
 	 *
+	 * If the underlying value's type is of type Class, the class name of it is returned as a String, which you can
+	 * then choose to load yourself (with either {@link ClassDiscovery#forName} or {@link Class#forName}). This is done
+	 * to prevent loading classes referenced in annotations by default.
+	 *
 	 * @param forName
 	 * @return
 	 */
@@ -188,6 +193,10 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
 	}
 
 	private static boolean matches(Object[] args, Class... types) {
+		if(args == null) {
+			return types.length == 0;
+		}
+
 		if(args.length != types.length) {
 			return false;
 		}

src/main/java/com/laytonsmith/PureUtilities/ClassLoading/ClassMirror/ClassMirrorVisitor.java

@@ -217,7 +217,7 @@ public AnnotationMirrorVisitor(AnnotationVisitor next, AnnotationMirror mirror)
 		@Override
 		public void visit(String name, Object value) {
 			if(value instanceof Type) {
-				value = ((Type) value).getDescriptor();
+				value = ((Type) value).getClassName();
 			}
 			mirror.addAnnotationValue(name, value);
 			super.visit(name, value);

src/main/java/com/laytonsmith/PureUtilities/Common/Annotations/AnnotationChecks.java

@@ -5,18 +5,22 @@
 import com.laytonsmith.PureUtilities.Common.ReflectionUtils;
 import com.laytonsmith.PureUtilities.Common.StringUtils;
 import com.laytonsmith.PureUtilities.ExhaustiveVisitor;
+import com.laytonsmith.annotations.NonInheritImplements;
 import com.laytonsmith.annotations.typeof;
 import com.laytonsmith.core.constructs.CClassType;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.Parameter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * This class is run by maven at compile time, and checks to ensure that the various annotations referenced here are
@@ -138,4 +142,39 @@ public static void verifyExhaustiveVisitors() throws ClassNotFoundException {
 		}
 	}
 
+	public static void verifyNonInheritImplements() throws ClassNotFoundException {
+		Set<ClassMirror<?>> toVerify;
+		toVerify = ClassDiscovery.getDefaultInstance()
+				.getClassesWithAnnotation(NonInheritImplements.class);
+		Set<String> uhohs = new HashSet<>();
+		for(ClassMirror<?> c : toVerify) {
+			Class<?> iface = Class.forName(c.getAnnotation(NonInheritImplements.class).getValue("value").toString());
+			if(!iface.isInterface()) {
+				uhohs.add("The class given to @NonInheritImplements, tagged on " + c.getClassName() + " is not an interface, and must be.");
+				continue;
+			}
+			// It's an interface, so go through all the methods it has, and make sure that the class c contains all the
+			// methods.
+			for(Method im : iface.getDeclaredMethods()) {
+				try {
+					c.getMethod(im.getName(), im.getParameterTypes());
+				} catch(NoSuchMethodException ex) {
+					String msg = "The class " + c.getClassName() + " implements " + iface.getSimpleName() + " but does not"
+							+ " implement the method public " + im.getReturnType().getSimpleName() + " " + im.getName() + "(";
+					List<String> params = new ArrayList<>();
+					msg += StringUtils.Join(im.getParameters(), ", ", ", ", ", ", "", (Object item) -> {
+						Parameter ci = (Parameter)item;
+						return ci.getType().getSimpleName() + " " + ci.getName();
+					});
+					msg += ") {}";
+					uhohs.add(msg);
+				}
+			}
+		}
+		if(!uhohs.isEmpty()) {
+			String error = StringUtils.Join(uhohs, "\n");
+			throw new Error(error);
+		}
+	}
+
 }

src/main/java/com/laytonsmith/annotations/NonInheritImplements.java

@@ -0,0 +1,81 @@
+package com.laytonsmith.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/**
+ * A class that must implement the methods of the given interface, but whose subclasses are not necessarily required to
+ * implement them. The value must be an interface, or a compile error will be given. Note that classes that are tagged
+ * with this are not directly castable to the specified interface, but will have all the methods required of them at
+ * compile time. Further, it is also allowed for a subclass to be tagged with this, yet a superclass (which may or may
+ * not be tagged with it) to actually provide the implementation. It is also an error to tag a class which is already an
+ * instanceof this interface.
+ *
+ * A good use case for this mechanism is the case of serialization. Which it is useful to provide a default
+ * serialization method, not all subclasses may want to be serializable themselves. However, if the superclass defines
+ * itself as serializable, all subclasses would then be required to implement these methods, even if they do not
+ * want to be serializable.
+ *
+ * For convenience, this interface also provides a Cast method and an Instanceof method, which replace the Java cast
+ * mechanism and instanceof mechanism to be aware of the fact that the cast appears to not work.
+ * @author cailin
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface NonInheritImplements {
+	Class<?> value();
+
+
+	/**
+	 * Provides helper methods for operations on a {@link NonInheritImplements} ecosystem.
+	 */
+	public static class Helper {
+
+		// No constructing allowed!
+		private Helper(){}
+
+		/**
+		 * Casts a given object to the given type, assuming it actually is truly castable to the specified type. (Either
+		 * because it implements the interface, or NonInheritImplements it.) Proxies are used as necessary to actually
+		 * provide a first class interface.
+		 * @param <T> The return interface type
+		 * @param castType The return interface type
+		 * @param o The object to cast
+		 * @return The original object, cast to the appropriate type
+		 * @throws If the underlying object does not implement the correct type
+		 */
+		public static <T> T Cast(Class<T> castType, Object o) throws ClassCastException {
+			NonInheritImplements nii = o.getClass().getAnnotation(NonInheritImplements.class);
+			if(castType.isAssignableFrom(o.getClass())) {
+				return castType.cast(o);
+			} else if(nii != null) {
+				Class<?> iface = nii.value();
+				@SuppressWarnings("unchecked")
+				T ifaceProxy = (T) Proxy.newProxyInstance(o.getClass().getClassLoader(), new Class[]{iface}, (Object proxy, Method method, Object[] args) -> {
+					return o.getClass().getMethod(method.getName(), method.getParameterTypes()).invoke(o, args);
+				});
+				return ifaceProxy;
+			} else {
+				throw new ClassCastException("The object cannot be cast to " + castType.getName());
+			}
+		}
+
+		/**
+		 * Works similar to the java {@code o instanceof value} mechanism, but is aware of the NonInheritImplements
+		 * mechanism. It also checks to see if the object is castable using the normal cast mechanism too, but in
+		 * general should not replace the instanceof keyword for normal use.
+		 * @param o
+		 * @param value
+		 * @return
+		 */
+		public static boolean Instanceof(Object o, Class<?> value) {
+			return value.isAssignableFrom(o.getClass())
+					|| o.getClass().getAnnotation(NonInheritImplements.class) != null;
+		}
+	}
+}

src/main/java/com/laytonsmith/core/MainSandbox.java

@@ -1,10 +1,21 @@
 package com.laytonsmith.core;
 
+import com.laytonsmith.annotations.NonInheritImplements;
+
 /**
  * This class is for testing concepts
  */
 public class MainSandbox {
 
+	public static interface B1 {
+		String method(int i, String b);
+	}
+	@NonInheritImplements(B1.class)
+	public static class A1 {
+		public String method(int i, String b) {
+			return "";
+		}
+	}
 	public static void main(String[] argv) throws Exception {
 
 	}

src/test/java/com/laytonsmith/PureUtilities/NonInheritImplementsTest.java

@@ -0,0 +1,61 @@
+package com.laytonsmith.PureUtilities;
+
+import com.laytonsmith.annotations.NonInheritImplements;
+import org.junit.After;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ *
+ * @author cailin
+ */
+public class NonInheritImplementsTest {
+
+	public static class A1 implements B1 {
+		@Override
+		public void method(){}
+	}
+	public static interface B1 {
+		void method();
+	}
+
+	@Test
+	public void testNormalWorks() throws Exception {
+		assertThat(NonInheritImplements.Helper.Instanceof(new A1(), B1.class), is(true));
+		A1 a1 = new A1();
+		B1 b1 = NonInheritImplements.Helper.Cast(B1.class, a1);
+		assertTrue(a1 == b1);
+	}
+
+	@Test(expected=ClassCastException.class)
+	public void testNormalFailsCorrectly1() throws Exception {
+		assertThat(NonInheritImplements.Helper.Instanceof(new A1(), NonInheritImplements.class), is(false));
+		NonInheritImplements.Helper.Cast(NonInheritImplements.class, this);
+	}
+
+	@NonInheritImplements(B2.class)
+	public static class A2 {
+		public String method2(int i) {
+			return Integer.toString(i);
+		}
+	}
+
+	public static interface B2 {
+		String method2(int i);
+	}
+
+	@Test
+	public void testProxyWorks() throws Exception {
+		assertThat(NonInheritImplements.Helper.Instanceof(new A2(), B2.class), is(true));
+		A2 a2 = new A2();
+		B2 b2 = NonInheritImplements.Helper.Cast(B2.class, a2);
+		assertThat(b2.method2(12), is("12"));
+	}
+
+}