// Path: src/main/java/de/danielbechler/diff/selector/ElementSelector.java
// public abstract class ElementSelector
// {
// 	public abstract String toHumanReadableString();
// 
// 	/**
// 	 * Must be implemented in a way so that this element can be distinguished from the other ones.
// 	 *
// 	 * @param obj The object to check equality against.
// 	 * @return <code>true</code> is the given object equals this one, otherwise <code>false</code>.
// 	 */
// 	public abstract boolean equals(Object obj);
// 
// 	/**
// 	 * Make sure to implement this properly. If two elements are equal, their hash code must be equal as well.
// 	 * However, it is absolutely okay if two unequal elements return the same hash code. A simple implementation
// 	 * could just return <code>0</code>.
// 	 *
// 	 * @return The hash code of this element.
// 	 */
// 	public abstract int hashCode();
// 
// 	/**
// 	 * The string representation will only be used to print readable property paths for debug purposes.
// 	 *
// 	 * @return A string representation of this element for debug purposes.
// 	 */
// 	public final String toString()
// 	{
// 		return toHumanReadableString();
// 	}
// }
// 
// Path: src/main/java/de/danielbechler/diff/selector/RootElementSelector.java
// public final class RootElementSelector extends ElementSelector
// {
// 	private static final RootElementSelector instance = new RootElementSelector();
// 
// 	RootElementSelector()
// 	{
// 	}
// 
// 	public static RootElementSelector getInstance()
// 	{
// 		return instance;
// 	}
// 
// 	@Override
// 	public String toHumanReadableString()
// 	{
// 		return "";
// 	}
// 
// 	@Override
// 	public boolean equals(final Object element)
// 	{
// 		if (this == element)
// 		{
// 			return true;
// 		}
// 		if (element != null && getClass().equals(element.getClass()))
// 		{
// 			return true;
// 		}
// 		return false;
// 	}
// 
// 	@Override
// 	public int hashCode()
// 	{
// 		return 0;
// 	}
// }
// 
// Path: src/main/java/de/danielbechler/util/Assert.java
// public class Assert
// {
// 	private Assert()
// 	{
// 	}
// 
// 	public static void equalTypesOrNull(final Object... objects)
// 	{
// 		final Collection<Class<?>> types = Classes.typesOf(objects);
// 		Class<?> previousType = null;
// 		for (final Class<?> type : types)
// 		{
// 			if (previousType != null && !type.equals(previousType))
// 			{
// 				throw new IllegalArgumentException("The given objects should be either null or of the same type ('" + previousType + "') = " + types);
// 			}
// 			previousType = type;
// 		}
// 	}
// 
// 	public static void notNull(final Object object, final String name)
// 	{
// 		if (object == null)
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null");
// 		}
// 	}
// 
// 	public static void notEmpty(final Collection<?> collection, final String name)
// 	{
// 		if (Collections.isEmpty(collection))
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null or empty");
// 		}
// 	}
// 
// 	/**
// 	 * Same as {@link #hasText(String, String)}.
// 	 *
// 	 * @see #hasText(String, String)
// 	 */
// 	public static void notEmpty(final String text, final String name) throws IllegalArgumentException
// 	{
// 		hasText(text, name);
// 	}
// 
// 	/**
// 	 * Ensures that the given <code>value</code> contains characters.
// 	 *
// 	 * @param value The value to check.
// 	 * @param name  The name of the variable (used for the exception message).
// 	 *
// 	 * @throws IllegalArgumentException If the given value is <code>null</code> or doesn't contain any non-whitespace
// 	 *                                  characters.
// 	 */
// 	public static void hasText(final String value, final String name) throws IllegalArgumentException
// 	{
// 		if (Strings.isEmpty(name)) // Yo dawg, I heard you like assertions, so I put an assertion in your assertion
// 		{
// 			throw new IllegalArgumentException("'name' must not be null or empty");
// 		}
// 		if (Strings.isEmpty(value))
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null or empty");
// 		}
// 	}
// }


import de.danielbechler.diff.selector.ElementSelector;
import de.danielbechler.diff.selector.RootElementSelector;
import de.danielbechler.util.Assert;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
		}
		else
		{
			for (final NodePathValueHolder<T> valueHolder : elementValueHolders.values())
			{
				if (valueHolder.containsValue(value))
				{
					return true;
				}
			}
			return false;
		}
	}

	public void collect(final Collector<T> collector)
	{
		collect(null, collector);
	}

	private void collect(final NodePath nodePath, final Collector<T> collector)
	{
		if (nodePath != null && value != null)
		{
			collector.it(nodePath, value);
		}
		for (final Map.Entry<ElementSelector, NodePathValueHolder<T>> entry : elementValueHolders.entrySet())
		{
			final NodePath childNodePath;
			final ElementSelector elementSelector = entry.getKey();
			final NodePathValueHolder<T> valueHolder = entry.getValue();
// Path: src/main/java/de/danielbechler/diff/selector/ElementSelector.java
// public abstract class ElementSelector
// {
// 	public abstract String toHumanReadableString();
// 
// 	/**
// 	 * Must be implemented in a way so that this element can be distinguished from the other ones.
// 	 *
// 	 * @param obj The object to check equality against.
// 	 * @return <code>true</code> is the given object equals this one, otherwise <code>false</code>.
// 	 */
// 	public abstract boolean equals(Object obj);
// 
// 	/**
// 	 * Make sure to implement this properly. If two elements are equal, their hash code must be equal as well.
// 	 * However, it is absolutely okay if two unequal elements return the same hash code. A simple implementation
// 	 * could just return <code>0</code>.
// 	 *
// 	 * @return The hash code of this element.
// 	 */
// 	public abstract int hashCode();
// 
// 	/**
// 	 * The string representation will only be used to print readable property paths for debug purposes.
// 	 *
// 	 * @return A string representation of this element for debug purposes.
// 	 */
// 	public final String toString()
// 	{
// 		return toHumanReadableString();
// 	}
// }
// 
// Path: src/main/java/de/danielbechler/diff/selector/RootElementSelector.java
// public final class RootElementSelector extends ElementSelector
// {
// 	private static final RootElementSelector instance = new RootElementSelector();
// 
// 	RootElementSelector()
// 	{
// 	}
// 
// 	public static RootElementSelector getInstance()
// 	{
// 		return instance;
// 	}
// 
// 	@Override
// 	public String toHumanReadableString()
// 	{
// 		return "";
// 	}
// 
// 	@Override
// 	public boolean equals(final Object element)
// 	{
// 		if (this == element)
// 		{
// 			return true;
// 		}
// 		if (element != null && getClass().equals(element.getClass()))
// 		{
// 			return true;
// 		}
// 		return false;
// 	}
// 
// 	@Override
// 	public int hashCode()
// 	{
// 		return 0;
// 	}
// }
// 
// Path: src/main/java/de/danielbechler/util/Assert.java
// public class Assert
// {
// 	private Assert()
// 	{
// 	}
// 
// 	public static void equalTypesOrNull(final Object... objects)
// 	{
// 		final Collection<Class<?>> types = Classes.typesOf(objects);
// 		Class<?> previousType = null;
// 		for (final Class<?> type : types)
// 		{
// 			if (previousType != null && !type.equals(previousType))
// 			{
// 				throw new IllegalArgumentException("The given objects should be either null or of the same type ('" + previousType + "') = " + types);
// 			}
// 			previousType = type;
// 		}
// 	}
// 
// 	public static void notNull(final Object object, final String name)
// 	{
// 		if (object == null)
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null");
// 		}
// 	}
// 
// 	public static void notEmpty(final Collection<?> collection, final String name)
// 	{
// 		if (Collections.isEmpty(collection))
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null or empty");
// 		}
// 	}
// 
// 	/**
// 	 * Same as {@link #hasText(String, String)}.
// 	 *
// 	 * @see #hasText(String, String)
// 	 */
// 	public static void notEmpty(final String text, final String name) throws IllegalArgumentException
// 	{
// 		hasText(text, name);
// 	}
// 
// 	/**
// 	 * Ensures that the given <code>value</code> contains characters.
// 	 *
// 	 * @param value The value to check.
// 	 * @param name  The name of the variable (used for the exception message).
// 	 *
// 	 * @throws IllegalArgumentException If the given value is <code>null</code> or doesn't contain any non-whitespace
// 	 *                                  characters.
// 	 */
// 	public static void hasText(final String value, final String name) throws IllegalArgumentException
// 	{
// 		if (Strings.isEmpty(name)) // Yo dawg, I heard you like assertions, so I put an assertion in your assertion
// 		{
// 			throw new IllegalArgumentException("'name' must not be null or empty");
// 		}
// 		if (Strings.isEmpty(value))
// 		{
// 			throw new IllegalArgumentException("'" + name + "' must not be null or empty");
// 		}
// 	}
// }


// Path: src/main/java/de/danielbechler/diff/path/NodePathValueHolder.java
import de.danielbechler.diff.selector.ElementSelector;
import de.danielbechler.diff.selector.RootElementSelector;
import de.danielbechler.util.Assert;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

		}
		else
		{
			for (final NodePathValueHolder<T> valueHolder : elementValueHolders.values())
			{
				if (valueHolder.containsValue(value))
				{
					return true;
				}
			}
			return false;
		}
	}

	public void collect(final Collector<T> collector)
	{
		collect(null, collector);
	}

	private void collect(final NodePath nodePath, final Collector<T> collector)
	{
		if (nodePath != null && value != null)
		{
			collector.it(nodePath, value);
		}
		for (final Map.Entry<ElementSelector, NodePathValueHolder<T>> entry : elementValueHolders.entrySet())
		{
			final NodePath childNodePath;
			final ElementSelector elementSelector = entry.getKey();
			final NodePathValueHolder<T> valueHolder = entry.getValue();
			if (elementSelector == RootElementSelector.getInstance())