Improved the fuzzy reflection system tremendously.

It is now possible to specify exactly what method or field you're
looking for, based on a number of different critera such as return
value, parameter count or parameter type, exceptions, modifiers, name -
all using a very fluent builder syntax.

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/AbstractFuzzyMatcher.java

@@ -0,0 +1,164 @@
+package com.comphenix.protocol.reflect;
+
+import javax.annotation.Nonnull;
+
+import com.google.common.primitives.Ints;
+
+/**
+ * Represents a matcher for fields, methods, constructors and classes.
+ * <p>
+ * This class should ideally never expose mutable state. Its round number must be immutable.
+ * @author Kristian
+ */
+public abstract class AbstractFuzzyMatcher<T> implements Comparable<AbstractFuzzyMatcher<T>> {
+	private Integer roundNumber;
+	
+	/**
+	 * Used to check class equality.
+	 * 
+	 * @author Kristian
+	 */
+	protected static class ClassMatcher {
+		/**
+		 * Match any class.
+		 */
+		public static final ClassMatcher MATCH_ALL = new ClassMatcher(null, true);
+		
+		private final Class<?> matcher;
+		private final boolean useAssignable;
+		
+		/**
+		 * Constructs a new class matcher.
+		 * @param matcher - the matching class, or NULL to represent anything. 
+		 * @param useAssignable - whether or not its acceptible for the input type to be a superclass.
+		 */
+		public ClassMatcher(Class<?> matcher, boolean useAssignable) {
+			this.matcher = matcher;
+			this.useAssignable = useAssignable;
+		}
+
+		/**
+		 * Determine if a given class is equivalent.
+		 * <p>
+		 * If the matcher is NULL, the result will only be TRUE if use assignable is TRUE.
+		 * @param input - the input class defined in the source file. 
+		 * @return TRUE if input is a matcher or a superclass of matcher, FALSE otherwise.
+		 */
+		public final boolean isClassEqual(@Nonnull Class<?> input) {
+			if (input == null)
+				throw new IllegalArgumentException("Input class cannot be NULL.");
+			
+			// Do our checking
+			if (matcher == null)
+				return useAssignable;
+			else if (useAssignable)
+				return input.isAssignableFrom(matcher); // matcher instanceof input
+			else
+				return input.equals(matcher);
+		}
+		
+		/**
+		 * Retrieve the number of superclasses of the specific class. 
+		 * <p>
+		 * Object is represented as one. All interfaces are one, unless they're derived.
+		 * @param clazz - the class to test.
+		 * @return The number of superclasses.
+		 */
+		public final int getClassNumber() {
+			Class<?> clazz = matcher;
+			int count = 0;
+			
+			// Move up the hierachy
+			while (clazz != null) {
+				count++;
+				clazz = clazz.getSuperclass();
+			}
+			return count;
+		}
+
+		/**
+		 * Retrieve the class we're comparing against.
+		 * @return Class to compare against.
+		 */
+		public Class<?> getMatcher() {
+			return matcher;
+		}
+
+		/**
+		 * Whether or not its acceptible for the input type to be a superclass.
+		 * @return TRUE if it is, FALSE otherwise.
+		 */
+		public boolean isUseAssignable() {
+			return useAssignable;
+		}
+		
+		@Override
+		public String toString() {
+			if (useAssignable)
+				return "Any " + matcher;
+			else
+				return "Exact " + matcher;
+		}
+	}
+	
+	/**
+	 * Determine if the given value is a match.
+	 * @param value - the value to match.
+	 * @return TRUE if it is a match, FALSE otherwise.
+	 */
+	public abstract boolean isMatch(T value);
+	
+	/**
+	 * Calculate the round number indicating when this matcher should be applied. 
+	 * <p>
+	 * Matchers with a lower round number are applied before matchers with a higher round number.
+	 * <p>
+	 * By convention, this round number should be negative, except for zero in the case of a matcher 
+	 * that accepts any value. A good implementation should return the inverted tree depth (class hierachy) 
+	 * of the least specified type used in the matching. Thus {@link Integer} will have a lower round number than
+	 * {@link Number}.
+	 * 
+	 * @return A number (positive or negative) that is used to order matchers.
+	 */
+	protected abstract int calculateRoundNumber();
+	
+	/**
+	 * Retrieve the cached round number. This should never change once calculated.
+	 * <p>
+	 * Matchers with a lower round number are applied before matchers with a higher round number.
+	 * @return The round number.
+	 * @see {@link #calculateRoundNumber()}
+	 */
+	public final int getRoundNumber() {
+		if (roundNumber == null) {
+			return roundNumber = calculateRoundNumber();
+		} else {
+			return roundNumber;
+		}
+	}
+	
+	/**
+	 * Combine two round numbers by taking the highest non-zero number, or return zero.
+	 * @param roundA - the first round number.
+	 * @param roundB - the second round number.
+	 * @return The combined round number.
+	 */
+	protected final int combineRounds(int roundA, int roundB) {
+		if (roundA == 0)
+			return roundB;
+		else if (roundB == 0)
+			return roundA;
+		else
+			return Math.max(roundA, roundB);
+	}
+		
+	@Override
+	public int compareTo(AbstractFuzzyMatcher<T> obj) {
+		if (obj instanceof AbstractFuzzyMatcher) {
+			AbstractFuzzyMatcher<?> matcher = (AbstractFuzzyMatcher<?>) obj;
+			return Ints.compare(getRoundNumber(), matcher.getRoundNumber());
+		}
+		// No match
+		return -1;
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/AbstractFuzzyMember.java

@@ -0,0 +1,136 @@
+package com.comphenix.protocol.reflect;
+
+import java.lang.reflect.Member;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents a matcher that matches members.
+ * 
+ * @author Kristian
+ * @param <T> - type that it matches.
+ */
+public abstract class AbstractFuzzyMember<T extends Member> extends AbstractFuzzyMatcher<T> {
+	// Accessibility matchers
+	private int modifiersRequired;
+	private int modifiersBanned;
+	private Pattern nameRegex;
+	private ClassMatcher declaringMatcher = ClassMatcher.MATCH_ALL;
+	
+	/**
+	 * Whether or not this contract can be modified.
+	 */
+	protected transient boolean sealed;
+	
+	/**
+	 * Represents a builder of a fuzzy member contract.
+	 * 
+	 * @author Kristian
+	 */
+	public static abstract class Builder<T extends AbstractFuzzyMember<?>> {
+		protected T member = initialMember();
+
+		public Builder<T> requireModifier(int modifier) {
+			member.modifiersRequired |= modifier;
+			return this;
+		}
+		
+		public Builder<T> banModifier(int modifier) {
+			member.modifiersBanned |= modifier;
+			return this;
+		}
+		
+		public Builder<T> nameRegex(String regex) {
+			member.nameRegex = Pattern.compile(regex);
+			return this;
+		}
+		
+		public Builder<T> nameRegex(Pattern pattern) {
+			member.nameRegex = pattern;
+			return this;
+		}
+		
+		public Builder<T> nameExact(String name) {
+			return nameRegex(Pattern.quote(name));
+		}
+		
+		public Builder<T> declaringClassExactType(Class<?> declaringClass) {
+			member.declaringMatcher = new ClassMatcher(declaringClass, false);
+			return this;
+		}
+		
+		public Builder<T> declaringClassCanHold(Class<?> declaringClass) {
+			member.declaringMatcher = new ClassMatcher(declaringClass, true);
+			return this;
+		}
+		
+		/**
+		 * Construct a new instance of the current type.		
+		 * @return New instance.
+		 */
+		@Nonnull
+		protected abstract T initialMember();
+		
+		/**
+		 * Build a new instance of this type.
+		 * <p>
+		 * Builders should call {@link AbstractFuzzyMember#prepareBuild()} when constructing new objects.
+		 * @return New instance of this type.
+		 */
+		public abstract T build();
+	}
+	
+	protected AbstractFuzzyMember() {
+		// Only allow construction through the builder
+	}
+	
+	/**
+	 * Called before a builder is building a member and copying its state.
+	 * <p>
+	 * Use this to prepare any special values.
+	 */
+	protected void prepareBuild() {
+		// Permit any modifier if we havent's specified anything
+		if (modifiersRequired == 0) {
+			modifiersRequired = Integer.MAX_VALUE;
+		}
+	}
+	
+	// Clone a given contract
+	protected AbstractFuzzyMember(AbstractFuzzyMember<T> other) {
+		this.modifiersRequired = other.modifiersRequired;
+		this.modifiersBanned = other.modifiersBanned;
+		this.nameRegex = other.nameRegex;
+		this.declaringMatcher = other.declaringMatcher;
+		this.sealed = true;
+	}
+
+	@Override
+	public boolean isMatch(T value) {
+		int mods = value.getModifiers();
+		
+		// Match accessibility and name
+		return (mods & modifiersRequired) != 0 &&
+			   (mods & modifiersBanned) == 0 &&
+			   declaringMatcher.isClassEqual(value.getDeclaringClass()) &&
+			   isNameMatch(value.getName());
+	}
+	
+	private boolean isNameMatch(String name) {
+		if (nameRegex == null)
+			return true;
+		else
+			return nameRegex.matcher(name).matches();
+	}
+
+	@Override
+	protected int calculateRoundNumber() {
+		// Sanity check
+		if (!sealed) 
+			throw new IllegalStateException("Cannot calculate round number during construction.");
+		
+		// NULL is zero
+		return -declaringMatcher.getClassNumber();
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/FuzzyClassContract.java

@@ -0,0 +1,218 @@
+package com.comphenix.protocol.reflect;
+
+import java.lang.reflect.Field;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+
+/**
+ * Determine if a given class implements a given fuzzy (duck typed) contract.
+ * 
+ * @author Kristian
+ */
+public class FuzzyClassContract extends AbstractFuzzyMatcher<Class<?>> {
+	private final ImmutableList<AbstractFuzzyMatcher<Field>> fieldContracts;
+	private final ImmutableList<AbstractFuzzyMatcher<MethodInfo>> methodContracts;
+	private final ImmutableList<AbstractFuzzyMatcher<MethodInfo>> constructorContracts;
+	
+	/**
+	 * Represents a class contract builder.
+	 * @author Kristian
+	 *
+	 */
+	public static class Builder {
+		private List<AbstractFuzzyMatcher<Field>> fieldContracts = Lists.newArrayList();
+		private List<AbstractFuzzyMatcher<MethodInfo>> methodContracts = Lists.newArrayList();
+		private List<AbstractFuzzyMatcher<MethodInfo>> constructorContracts = Lists.newArrayList();
+		
+		/**
+		 * Add a new field contract.
+		 * @param matcher - new field contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder field(AbstractFuzzyMatcher<Field> matcher) {
+			fieldContracts.add(matcher);
+			return this;
+		}
+		
+		/**
+		 * Add a new field contract via a builder.
+		 * @param builder - builder for the new field contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder field(FuzzyFieldContract.Builder builder) {
+			return field(builder.build());
+		}
+		
+		/**
+		 * Add a new method contract.
+		 * @param matcher - new method contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder method(AbstractFuzzyMatcher<MethodInfo> matcher) {
+			methodContracts.add(matcher);
+			return this;
+		}
+		
+		/**
+		 * Add a new method contract via a builder.
+		 * @param builder - builder for the new method contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder method(FuzzyMethodContract.Builder builder) {
+			return method(builder.build());
+		}
+		
+		/**
+		 * Add a new constructor contract.
+		 * @param matcher - new constructor contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder constructor(AbstractFuzzyMatcher<MethodInfo> matcher) {
+			constructorContracts.add(matcher);
+			return this;
+		}
+		
+		/**
+		 * Add a new constructor contract via a builder.
+		 * @param builder - builder for the new constructor contract.
+		 * @return This builder, for chaining.
+		 */
+		public Builder constructor(FuzzyMethodContract.Builder builder) {
+			return constructor(builder.build());
+		}
+
+		public FuzzyClassContract build() {
+			Collections.sort(fieldContracts);
+			Collections.sort(methodContracts);
+			Collections.sort(constructorContracts);
+			
+			// Construct a new class matcher
+			return new FuzzyClassContract(
+						ImmutableList.copyOf(fieldContracts),
+						ImmutableList.copyOf(methodContracts),
+						ImmutableList.copyOf(constructorContracts)
+			);
+		}
+	}
+
+	/**
+	 * Construct a new fuzzy class contract builder.
+	 * @return A new builder.
+	 */
+	public static Builder newBuilder() {
+		return new Builder();
+	}
+	
+	/**
+	 * Constructs a new fuzzy class contract with the given contracts.
+	 * @param fieldContracts - field contracts.
+	 * @param methodContracts - method contracts.
+	 * @param constructorContracts - constructor contracts.
+	 */
+	private FuzzyClassContract(ImmutableList<AbstractFuzzyMatcher<Field>> fieldContracts,
+							   ImmutableList<AbstractFuzzyMatcher<MethodInfo>> methodContracts,
+							   ImmutableList<AbstractFuzzyMatcher<MethodInfo>> constructorContracts) {
+		super();
+		this.fieldContracts = fieldContracts;
+		this.methodContracts = methodContracts;
+		this.constructorContracts = constructorContracts;
+	}
+
+	/**
+	 * Retrieve an immutable list of every field contract.
+	 * <p>
+	 * This list is ordered in descending order of priority.
+	 * @return List of every field contract.
+	 */
+	public ImmutableList<AbstractFuzzyMatcher<Field>> getFieldContracts() {
+		return fieldContracts;
+	}
+
+	/**
+	 * Retrieve an immutable list of every method contract.
+	 * <p>
+	 * This list is ordered in descending order of priority.
+	 * @return List of every method contract.
+	 */
+	public ImmutableList<AbstractFuzzyMatcher<MethodInfo>> getMethodContracts() {
+		return methodContracts;
+	}
+
+	/**
+	 * Retrieve an immutable list of every constructor contract.
+	 * <p>
+	 * This list is ordered in descending order of priority.
+	 * @return List of every constructor contract.
+	 */
+	public ImmutableList<AbstractFuzzyMatcher<MethodInfo>> getConstructorContracts() {
+		return constructorContracts;
+	}
+	
+	@Override
+	protected int calculateRoundNumber() {
+		// Find the highest round number
+		return combineRounds(findHighestRound(fieldContracts), 
+			   combineRounds(findHighestRound(methodContracts), 
+					    	 findHighestRound(constructorContracts)));
+	}
+	
+	private <T> int findHighestRound(Collection<AbstractFuzzyMatcher<T>> list) {
+		int highest = 0;
+		
+		// Go through all the elements
+		for (AbstractFuzzyMatcher<T> matcher : list) 
+			highest = combineRounds(highest, matcher.getRoundNumber());
+		return highest;
+	}
+
+	@Override
+	public boolean isMatch(Class<?> value) {
+		FuzzyReflection reflection = FuzzyReflection.fromClass(value);
+		
+		// Make sure all the contracts are valid
+		return processContracts(reflection.getFields(), fieldContracts) &&
+			   processContracts(MethodInfo.fromMethods(reflection.getMethods()), methodContracts) &&
+			   processContracts(MethodInfo.fromConstructors(value.getDeclaredConstructors()), constructorContracts);
+	}
+
+	private <T> boolean processContracts(Collection<T> values, List<AbstractFuzzyMatcher<T>> matchers) {
+		boolean[] accepted = new boolean[matchers.size()];
+		int count = accepted.length;
+
+		// Process every value in turn
+		for (T value : values) {
+			int index = processValue(value, accepted, matchers);
+			
+			// See if this worked
+			if (index >= 0) {
+				accepted[index] = true;
+				count--;
+			}
+			
+			// Break early
+			if (count == 0)
+				return true;
+		}
+		return count == 0;
+	}
+	
+	private <T> int processValue(T value, boolean accepted[], List<AbstractFuzzyMatcher<T>> matchers) {
+		// The order matters
+		for (int i = 0; i < matchers.size(); i++) {
+			if (!accepted[i]) {
+				AbstractFuzzyMatcher<T> matcher = matchers.get(i);
+				
+				// Mark this as detected
+				if (matcher.isMatch(value)) {
+					return i;
+				}
+			}
+		}
+		
+		// Failure
+		return -1;
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/FuzzyFieldContract.java

@@ -0,0 +1,108 @@
+package com.comphenix.protocol.reflect;
+
+import java.lang.reflect.Field;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Represents a field matcher.
+ * 
+ * @author Kristian
+ */
+public class FuzzyFieldContract extends AbstractFuzzyMember<Field> {
+	private ClassMatcher typeMatcher = ClassMatcher.MATCH_ALL;
+	
+	public static class Builder extends AbstractFuzzyMember.Builder<FuzzyFieldContract> {
+		public Builder requireModifier(int modifier) {
+			super.requireModifier(modifier); 
+			return this;
+		}
+		
+		public Builder banModifier(int modifier) {
+			super.banModifier(modifier); 
+			return this;
+		}
+		
+		public Builder nameRegex(String regex) {
+			super.nameRegex(regex); 
+			return this;
+		}
+		
+		public Builder nameRegex(Pattern pattern) {
+			super.nameRegex(pattern); 
+			return this;
+		}
+		
+		public Builder nameExact(String name) {
+			super.nameExact(name); 
+			return this;
+		}
+		
+		public Builder declaringClassExactType(Class<?> declaringClass) {
+			super.declaringClassExactType(declaringClass); 
+			return this;
+		}
+		
+		public Builder declaringClassCanHold(Class<?> declaringClass) {
+			super.declaringClassCanHold(declaringClass); 
+			return this;
+		}
+		
+		@Override
+		@Nonnull
+		protected FuzzyFieldContract initialMember() {
+			return new FuzzyFieldContract();
+		}
+		
+		public Builder typeExact(Class<?> type) {
+			member.typeMatcher = new ClassMatcher(type, false);
+			return this;
+		}
+		
+		public Builder typeCanHold(Class<?> type) {
+			member.typeMatcher = new ClassMatcher(type, true);
+			return this;
+		}
+
+		@Override
+		public FuzzyFieldContract build() {
+			member.prepareBuild();
+			return new FuzzyFieldContract(member);
+		}
+	}
+
+	public static Builder newBuilder() {
+		return new Builder();
+	}
+	
+	private FuzzyFieldContract() {
+		// Only allow construction through the builder
+		super();
+	}
+	
+	/**
+	 * Create a new field contract from the given contract.
+	 * @param other - the contract to clone.
+	 */
+	private FuzzyFieldContract(FuzzyFieldContract other) {
+		super(other);
+		this.typeMatcher = other.typeMatcher;
+	}
+	
+	@Override
+	public boolean isMatch(Field value) {
+		if (super.isMatch(value)) {
+			return typeMatcher.isClassEqual(value.getType());
+		}
+		// No match
+		return false;
+	}
+	
+	@Override
+	protected int calculateRoundNumber() {
+		int current = -typeMatcher.getClassNumber();
+		
+		return combineRounds(super.calculateRoundNumber(), current);
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/FuzzyMethodContract.java

@@ -0,0 +1,293 @@
+package com.comphenix.protocol.reflect;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import javax.annotation.Nonnull;
+
+import org.apache.commons.lang.NotImplementedException;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Represents a contract for matching methods or constructors.
+ * 
+ * @author Kristian
+ */
+public class FuzzyMethodContract extends AbstractFuzzyMember<MethodInfo> {
+	private static class ParameterClassMatcher extends AbstractFuzzyMatcher<Class<?>[]> {
+		/**
+		 * The expected index.
+		 */
+		private final ClassMatcher typeMatcher;
+		private final Integer indexMatch;
+		
+		/**
+		 * Construct a new parameter class matcher. 
+		 * @param typeMatcher - class type matcher.
+		 */
+		public ParameterClassMatcher(@Nonnull ClassMatcher typeMatcher) {
+			this(typeMatcher, null);
+		}
+		
+		/**
+		 * Construct a new parameter class matcher. 
+		 * @param typeMatcher - class type matcher.
+		 * @param indexMatch - parameter index to match, or NULL for anything.
+		 */
+		public ParameterClassMatcher(@Nonnull ClassMatcher typeMatcher, Integer indexMatch) {
+			if (typeMatcher == null)
+				throw new IllegalArgumentException("Type matcher cannot be NULL.");
+			
+			this.typeMatcher = typeMatcher;
+			this.indexMatch = indexMatch;
+		}
+		
+		/**
+		 * See if there's a match for this matcher.
+		 * @param used - parameters that have been matched before.
+		 * @param params - the type of each parameter.
+		 * @return TRUE if this matcher matches any of the given parameters, FALSE otherwise.
+		 */
+		public boolean isParameterMatch(Class<?> param, int index) {
+			// Make sure the index is valid (or NULL)
+			if (indexMatch == null || indexMatch == index)
+				return typeMatcher.isClassEqual(param);
+			else
+				return false;
+		}
+
+		@Override
+		public boolean isMatch(Class<?>[] value) {
+			throw new NotImplementedException("Use the parameter match instead.");
+		}
+
+		@Override
+		protected int calculateRoundNumber() {
+			return -typeMatcher.getClassNumber();
+		}
+		
+		@Override
+		public String toString() {
+			return String.format("{Type: %s, Index: %s}", typeMatcher, indexMatch);
+		}
+	}
+	
+	// Match return value
+	private ClassMatcher returnMatcher = ClassMatcher.MATCH_ALL;
+	
+	// Handle parameters and exceptions
+	private List<ParameterClassMatcher> paramMatchers = Lists.newArrayList();
+	private List<ParameterClassMatcher> exceptionMatchers = Lists.newArrayList();
+	
+	// Expected parameter count
+	private Integer paramCount;
+	
+	public static class Builder extends AbstractFuzzyMember.Builder<FuzzyMethodContract> {
+		public Builder requireModifier(int modifier) {
+			super.requireModifier(modifier); 
+			return this;
+		}
+		
+		public Builder banModifier(int modifier) {
+			super.banModifier(modifier); 
+			return this;
+		}
+		
+		public Builder nameRegex(String regex) {
+			super.nameRegex(regex); 
+			return this;
+		}
+		
+		public Builder nameRegex(Pattern pattern) {
+			super.nameRegex(pattern); 
+			return this;
+		}
+		
+		public Builder nameExact(String name) {
+			super.nameExact(name); 
+			return this;
+		}
+		
+		public Builder declaringClassExactType(Class<?> declaringClass) {
+			super.declaringClassExactType(declaringClass); 
+			return this;
+		}
+		
+		public Builder declaringClassCanHold(Class<?> declaringClass) {
+			super.declaringClassCanHold(declaringClass); 
+			return this;
+		}
+		
+		public Builder parameterExactType(Class<?> type) {
+			member.paramMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, false)));
+			return this;
+		}
+		
+		public Builder parameterCanHold(Class<?> type) {
+			member.paramMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, true)));
+			return this;
+		}
+		
+		public Builder parameterExactType(Class<?> type, int index) {
+			member.paramMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, false), index));
+			return this;
+		}
+		
+		public Builder parameterCanHold(Class<?> type, int index) {
+			member.paramMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, true), index));
+			return this;
+		}
+		
+		public Builder parameterCount(int expectedCount) {
+			member.paramCount = expectedCount;
+			return this;
+		}
+		
+		public Builder returnTypeVoid() {
+			return returnTypeExact(Void.TYPE);
+		}
+		
+		public Builder returnTypeExact(Class<?> type) {
+			member.returnMatcher = new ClassMatcher(type, false);
+			return this;
+		}
+		
+		public Builder returnCanHold(Class<?> type) {
+			member.returnMatcher = new ClassMatcher(type, true);
+			return this;
+		}
+		
+		public Builder exceptionExactType(Class<?> type) {
+			member.exceptionMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, false)));
+			return this;
+		}
+		
+		public Builder exceptionCanHold(Class<?> type) {
+			member.exceptionMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, true)));
+			return this;
+		}
+		
+		public Builder exceptionExactType(Class<?> type, int index) {
+			member.exceptionMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, false), index));
+			return this;
+		}
+		
+		public Builder exceptionCanHold(Class<?> type, int index) {
+			member.exceptionMatchers.add(new ParameterClassMatcher(new ClassMatcher(type, true), index));
+			return this;
+		}
+		
+		@Override
+		@Nonnull
+		protected FuzzyMethodContract initialMember() {
+			return new FuzzyMethodContract();
+		}
+
+		@Override
+		public FuzzyMethodContract build() {
+			member.prepareBuild();
+			return new FuzzyMethodContract(member);
+		}
+		
+	}
+	
+	public static Builder newBuilder() {
+		return new Builder();
+	}
+	
+	private FuzzyMethodContract() {
+		// Only allow construction from the builder
+	}
+
+	private FuzzyMethodContract(FuzzyMethodContract other) {
+		super(other);
+		this.returnMatcher = other.returnMatcher;
+		this.paramMatchers = other.paramMatchers;
+		this.exceptionMatchers = other.exceptionMatchers;
+		this.paramCount = other.paramCount;
+	}
+	
+	@Override
+	protected void prepareBuild() {
+		super.prepareBuild();
+		
+		// Sort lists such that more specific tests are up front
+		Collections.sort(paramMatchers);
+		Collections.sort(exceptionMatchers);
+	}
+	
+	@Override
+	public boolean isMatch(MethodInfo value) {
+		if (super.isMatch(value)) {
+			Class<?>[] params = value.getParameterTypes();
+			Class<?>[] exceptions = value.getExceptionTypes();
+			
+			if (!returnMatcher.isClassEqual(value.getReturnType()))
+				return false;
+			if (paramCount != null && paramCount != value.getParameterTypes().length)
+				return false;
+
+			// Finally, check parameters and exceptions
+			return matchParameters(params, paramMatchers) && 
+				   matchParameters(exceptions, exceptionMatchers);
+		}
+		// No match
+		return false;
+	}
+	
+	private boolean matchParameters(Class<?>[] types, List<ParameterClassMatcher> matchers) {
+		boolean[] accepted = new boolean[matchers.size()];
+		int count = accepted.length;
+		
+		// Process every parameter in turn
+		for (int i = 0; i < types.length; i++) {
+			int matcherIndex = processValue(types[i], i, accepted, matchers);
+
+			if (matcherIndex >= 0) {
+				accepted[matcherIndex] = true;
+				count--;
+			}
+			
+			// Break early
+			if (count == 0)
+				return true;
+		}
+		return count == 0;
+	}
+	
+	private int processValue(Class<?> value, int index, boolean accepted[], List<ParameterClassMatcher> matchers) {
+		// The order matters
+		for (int i = 0; i < matchers.size(); i++) {
+			if (!accepted[i]) {
+				// See if we got jackpot
+				if (matchers.get(i).isParameterMatch(value, index)) {
+					return i;
+				}
+			}
+		}
+		
+		// Failure
+		return -1;
+	}
+	
+	@Override
+	protected int calculateRoundNumber() {
+		int current = 0;
+		
+		// Consider the return value first
+		current = -returnMatcher.getClassNumber();
+		
+		// Handle parameters
+		for (ParameterClassMatcher matcher : paramMatchers) {
+			current = combineRounds(current, matcher.calculateRoundNumber());
+		}
+		// And exceptions
+		for (ParameterClassMatcher matcher : exceptionMatchers) {
+			current = combineRounds(current, matcher.calculateRoundNumber());
+		}
+		
+		return combineRounds(super.calculateRoundNumber(), current);
+	}
+}

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/FuzzyReflection.java

@@ -17,6 +17,7 @@
 
 package com.comphenix.protocol.reflect;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
@@ -26,6 +27,8 @@ import java.util.List;
 import java.util.Set;
 import java.util.regex.Pattern;
 
+import com.google.common.collect.Lists;
+
 /**
  * Retrieves fields and methods by signature, not just name.
  * 
@@ -89,6 +92,42 @@ public class FuzzyReflection {
 		return source;
 	}
 	
+	/**
+	 * Retrieve the first method that matches.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level method.
+	 * @param matcher - the matcher to use.
+	 * @return The first method that satisfies the given matcher.
+	 * @throws IllegalArgumentException If the method cannot be found.
+	 */
+	public Method getMethod(AbstractFuzzyMatcher<MethodInfo> matcher) {
+		List<Method> result = getMethodList(matcher);
+		
+		if (result.size() > 0)
+			return result.get(0);
+		else
+			throw new IllegalArgumentException("Unable to find a method that matches " + matcher);
+	}
+	
+	/**
+	 * Retrieve a list of every method that matches the given matcher.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level methods.
+	 * @param matcher - the matcher to apply.
+	 * @return List of found methods.
+	 */
+	public List<Method> getMethodList(AbstractFuzzyMatcher<MethodInfo> matcher) {
+		List<Method> methods = Lists.newArrayList();
+		
+		// Add all matching fields to the list
+		for (Method method : getMethods()) {
+			if (matcher.isMatch(MethodInfo.fromMethod(method))) {
+				methods.add(method);
+			}
+		}
+		return methods;
+	}
+	
 	/**
 	 * Retrieves a method by looking at its name.
 	 * @param nameRegex -  regular expression that will match method names.
@@ -96,7 +135,6 @@ public class FuzzyReflection {
 	 * @throws IllegalArgumentException If the method cannot be found.
 	 */
 	public Method getMethodByName(String nameRegex) {
-		
 		Pattern match = Pattern.compile(nameRegex);
 		
 		for (Method method : getMethods()) {
@@ -118,7 +156,6 @@ public class FuzzyReflection {
 	 * @throws IllegalArgumentException If the method cannot be found.
 	 */
 	public Method getMethodByParameters(String name, Class<?>... args) {
-		
 		// Find the correct method to call
 		for (Method method : getMethods()) {
 			if (Arrays.equals(method.getParameterTypes(), args)) {
@@ -159,7 +196,6 @@ public class FuzzyReflection {
 	 * @throws IllegalArgumentException If the method cannot be found.
 	 */
 	public Method getMethodByParameters(String name, String returnTypeRegex, String[] argsRegex) {
-	
 		Pattern match = Pattern.compile(returnTypeRegex);
 		Pattern[] argMatch = new Pattern[argsRegex.length];
 		
@@ -199,7 +235,6 @@ public class FuzzyReflection {
 	 * @return Every method that satisfies the given constraints.
 	 */
 	public List<Method> getMethodListByParameters(Class<?> returnType, Class<?>[] args) {
-	
 		List<Method> methods = new ArrayList<Method>();
 		
 		// Find the correct method to call
@@ -274,6 +309,42 @@ public class FuzzyReflection {
 		return fields;
 	}
 	
+	/**
+	 * Retrieve the first field that matches.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level fields.
+	 * @param matcher - the matcher to use.
+	 * @return The first method that satisfies the given matcher.
+	 * @throws IllegalArgumentException If the method cannot be found.
+	 */
+	public Field getField(AbstractFuzzyMatcher<Field> matcher) {
+		List<Field> result = getFieldList(matcher);
+		
+		if (result.size() > 0)
+			return result.get(0);
+		else
+			throw new IllegalArgumentException("Unable to find a field that matches " + matcher);
+	}
+	
+	/**
+	 * Retrieve a list of every field that matches the given matcher.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level fields.
+	 * @param matcher - the matcher to apply.
+	 * @return List of found fields.
+	 */
+	public List<Field> getFieldList(AbstractFuzzyMatcher<Field> matcher) {
+		List<Field> fields = Lists.newArrayList();
+		
+		// Add all matching fields to the list
+		for (Field field : getFields()) {
+			if (matcher.isMatch(field)) {
+				fields.add(field);
+			}
+		}
+		return fields;
+	}
+	
 	/**
 	 * Retrieves a field by type.
 	 * <p>
@@ -336,8 +407,46 @@ public class FuzzyReflection {
 									       typeRegex + " in " + source.getName());
 	}
 	
+	/**
+	 * Retrieve the first constructor that matches.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level constructors.
+	 * @param matcher - the matcher to use.
+	 * @return The first constructor that satisfies the given matcher.
+	 * @throws IllegalArgumentException If the constructor cannot be found.
+	 */
+	public Constructor<?> getConstructor(AbstractFuzzyMatcher<MethodInfo> matcher) {
+		List<Constructor<?>> result = getConstructorList(matcher);
+		
+		if (result.size() > 0)
+			return result.get(0);
+		else
+			throw new IllegalArgumentException("Unable to find a method that matches " + matcher);
+	}
+	
+	/**
+	 * Retrieve a list of every constructor that matches the given matcher.
+	 * <p>
+	 * ForceAccess must be TRUE in order for this method to access private, protected and package level constructors.
+	 * @param matcher - the matcher to apply.
+	 * @return List of found constructors.
+	 */
+	public List<Constructor<?>> getConstructorList(AbstractFuzzyMatcher<MethodInfo> matcher) {
+		List<Constructor<?>> constructors = Lists.newArrayList();
+		
+		// Add all matching fields to the list
+		for (Constructor<?> constructor : getConstructors()) {
+			if (matcher.isMatch(MethodInfo.fromConstructor(constructor))) {
+				constructors.add(constructor);
+			}
+		}
+		return constructors;
+	}
+	
 	/**
 	 * Retrieves all private and public fields in declared order (after JDK 1.5).
+	 * <p>
+	 * Private, protected and package fields are ignored if forceAccess is FALSE.
 	 * @return Every field.
 	 */
 	public Set<Field> getFields() {
@@ -350,6 +459,8 @@ public class FuzzyReflection {
 	
 	/**
 	 * Retrieves all private and public methods in declared order (after JDK 1.5).
+	 * <p>
+	 * Private, protected and package methods are ignored if forceAccess is FALSE.
 	 * @return Every method.
 	 */
 	public Set<Method> getMethods() {
@@ -360,6 +471,19 @@ public class FuzzyReflection {
 			return setUnion(source.getMethods());
 	}
 	
+	/**
+	 * Retrieves all private and public constructors in declared order (after JDK 1.5).
+	 * <p>
+	 * Private, protected and package constructors are ignored if forceAccess is FALSE.
+	 * @return Every constructor.
+	 */
+	public Set<Constructor<?>> getConstructors() {
+		if (forceAccess)
+			return setUnion(source.getDeclaredConstructors());
+		else
+			return setUnion(source.getConstructors());
+	}
+	
 	// Prevent duplicate fields
 	private static <T> Set<T> setUnion(T[]... array) {
 		Set<T> result = new LinkedHashSet<T>();

ProtocolLib/src/main/java/com/comphenix/protocol/reflect/MethodInfo.java

@@ -0,0 +1,230 @@
+package com.comphenix.protocol.reflect;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.TypeVariable;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.apache.commons.lang.NotImplementedException;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Represents a method or a constructor.
+ * 
+ * @author Kristian
+ */
+public abstract class MethodInfo implements GenericDeclaration, Member {
+	/**
+	 * Wraps a method as a MethodInfo object.
+	 * @param method - the method to wrap.
+	 * @return The wrapped method.
+	 */
+	public static MethodInfo fromMethod(final Method method) {
+		return new MethodInfo() {
+			@Override
+			public String getName() {
+				return method.getName();
+			}
+			@Override
+			public Class<?>[] getParameterTypes() {
+				return method.getParameterTypes();
+			}
+			@Override
+			public Class<?> getDeclaringClass() {
+				return method.getDeclaringClass();
+			}
+			@Override
+			public Class<?> getReturnType() {
+				return method.getReturnType();
+			}
+			@Override
+			public int getModifiers() {
+				return method.getModifiers();
+			}
+			@Override
+			public Class<?>[] getExceptionTypes() {
+				return method.getExceptionTypes();
+			}
+			@Override
+			public TypeVariable<?>[] getTypeParameters() {
+				return method.getTypeParameters();
+			}
+			@Override
+			public String toGenericString() {
+				return method.toGenericString();
+			}
+			@Override
+			public String toString() {
+				return method.toString();
+			}
+			@Override
+			public boolean isSynthetic() {
+				return method.isSynthetic();
+			}
+			@Override
+			public int hashCode() {
+				return method.hashCode();
+			}
+			@Override
+			public boolean isConstructor() {
+				return false;
+			}
+		};
+	}
+	
+	/**
+	 * Construct a list of method infos from a given array of methods.
+	 * @param methods - array of methods.
+	 * @return Method info list.
+	 */
+	public static Collection<MethodInfo> fromMethods(Method[] methods) {
+		return fromMethods(Arrays.asList(methods));
+	}
+
+	/**
+	 * Construct a list of method infos from a given collection of methods.
+	 * @param methods - list of methods.
+	 * @return Method info list.
+	 */
+	public static List<MethodInfo> fromMethods(Collection<Method> methods) {
+		List<MethodInfo> infos = Lists.newArrayList();
+		
+		for (Method method : methods)
+			infos.add(fromMethod(method));
+		return infos;
+	}
+	
+	/**
+	 * Wraps a constructor as a method information object.
+	 * @param constructor - the constructor to wrap.
+	 * @return A wrapped constructor.
+	 */
+	public static MethodInfo fromConstructor(final Constructor<?> constructor) {
+		return new MethodInfo() {
+			@Override
+			public String getName() {
+				return constructor.getName();
+			}
+			@Override
+			public Class<?>[] getParameterTypes() {
+				return constructor.getParameterTypes();
+			}
+			@Override
+			public Class<?> getDeclaringClass() {
+				return constructor.getDeclaringClass();
+			}
+			@Override
+			public Class<?> getReturnType() {
+				return Void.class;
+			}
+			@Override
+			public int getModifiers() {
+				return constructor.getModifiers();
+			}
+			@Override
+			public Class<?>[] getExceptionTypes() {
+				return constructor.getExceptionTypes();
+			}
+			@Override
+			public TypeVariable<?>[] getTypeParameters() {
+				return constructor.getTypeParameters();
+			}
+			@Override
+			public String toGenericString() {
+				return constructor.toGenericString();
+			}
+			@Override
+			public String toString() {
+				return constructor.toString();
+			}
+			@Override
+			public boolean isSynthetic() {
+				return constructor.isSynthetic();
+			}
+			@Override
+			public int hashCode() {
+				return constructor.hashCode();
+			}
+			@Override
+			public boolean isConstructor() {
+				return true;
+			}
+		};
+	}
+	
+	/**
+	 * Construct a list of method infos from a given array of constructors.
+	 * @param constructors - array of constructors.
+	 * @return Method info list.
+	 */
+	public static Collection<MethodInfo> fromConstructors(Constructor<?>[] constructors) {
+		return fromConstructors(Arrays.asList(constructors));
+	}
+	
+	/**
+	 * Construct a list of method infos from a given collection of constructors.
+	 * @param constructors - list of constructors.
+	 * @return Method info list.
+	 */
+	public static List<MethodInfo> fromConstructors(Collection<Constructor<?>> constructors) {
+		List<MethodInfo> infos = Lists.newArrayList();
+		
+		for (Constructor<?> constructor : constructors)
+			infos.add(fromConstructor(constructor));
+		return infos;
+	}
+	
+	/**
+	 * Returns a string describing this method or constructor
+	 * @return A string representation of the object.
+	 * @see {@link Method#toString()} or {@link Constructor#toString()}
+	 */
+	@Override
+	public String toString() {
+		throw new NotImplementedException();
+	}
+
+	/**
+	 * Returns a string describing this method or constructor, including type parameters.
+	 * @return A string describing this Method, include type parameters
+	 * @see {@link Method#toGenericString()} or {@link Constructor#toGenericString()}
+	 */
+	public abstract String toGenericString();
+	
+	/**
+	 * Returns an array of Class objects that represent the types of the exceptions declared to be thrown by the 
+	 * underlying method or constructor represented by this MethodInfo object.
+	 * @return The exception types declared as being thrown by the method or constructor this object represents.
+	 * @see {@link Method#getExceptionTypes()} or {@link Constructor#getExceptionTypes()}
+	 */
+	public abstract Class<?>[] getExceptionTypes();
+
+	/**
+	 * Returns a Class object that represents the formal return type of the method or constructor 
+	 * represented by this MethodInfo object. 
+	 * <p>
+	 * This is always {@link Void} for constructors.
+	 * @return The return value, or Void if a constructor.
+	 * @see {@link Method#getReturnType()}
+	 */
+	public abstract Class<?> getReturnType();
+
+	/**
+	 * Returns an array of Class objects that represent the formal parameter types, in declaration order, 
+	 * of the method or constructor represented by this MethodInfo object.
+	 * @return The parameter types for the method or constructor this object represents.
+	 * @see {@link Method#getParameterTypes()} or {@link Constructor#getParameterTypes()}
+	 */
+	public abstract Class<?>[] getParameterTypes();
+	
+	/**
+	 * Determine if this is a constructor or not.
+	 * @return TRUE if this represents a constructor, FALSE otherwise.
+	 */
+	public abstract boolean isConstructor();
+}