if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        AbstractClasspathEntry that = (AbstractClasspathEntry) o;
        return exported == that.exported
            && Objects.equal(path, that.path)
            && Objects.equal(accessRules, that.accessRules)

    }

    public void enhance(Classpath classpath) {
        for (ClasspathEntry entry : classpath.getEntries()) {
            if (entry instanceof AbstractClasspathEntry) {
                AbstractClasspathEntry classpathEntry = (AbstractClasspathEntry) entry;
                Map<String, Object> wtpEntries = createDeploymentAttribute(classpathEntry);
                classpathEntry.getEntryAttributes().putAll(wtpEntries);

    }

    private class EclipseDependenciesVisitor implements IdeDependencyVisitor {

        private final List<AbstractClasspathEntry> projects = new ArrayList<>();
        private final List<AbstractClasspathEntry> modules = new ArrayList<>();
        private final List<AbstractClasspathEntry> files = new ArrayList<>();
        private final Multimap<String, String> pathToSourceSets = collectLibraryToSourceSetMapping();

// tag::module-when-merged[]
import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry
// end::module-when-merged[]
// tag::module-before-merged[]
// tag::module-when-merged[]
import org.gradle.plugins.ide.eclipse.model.Classpath
// end::module-when-merged[]
// end::module-before-merged[]
// tag::project-before-merged[]
import org.gradle.plugins.ide.eclipse.model.Project
// end::project-before-merged[]
// tag::wtp-with-xml[]

 * limitations under the License.
 */

package org.gradle.plugins.ide.eclipse.model.internal;

import com.google.common.collect.ImmutableList;
import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry;
import org.gradle.plugins.ide.eclipse.model.ClasspathEntry;
import org.gradle.plugins.ide.eclipse.model.Container;
import org.gradle.plugins.ide.eclipse.model.EclipseClasspath;

 * limitations under the License.
 */

package org.gradle.plugins.ide.eclipse.model;

import groovy.util.Node;

/**
 * A container classpath entry.
 */
public class Container extends AbstractClasspathEntry {

    public Container(Node node) {
        super(node);
    }

    public Container(String path) {
        super(path);
    }

    @Override
    public String getKind() {

                                println "Checking property \${prop.name} on \${convertedClass.name}"
                                if (convertedClass == org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry && prop.name == "exported") {
                                    return
                                }

import javax.annotation.Nullable;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Common superclass for the library elements.
 */
public abstract class AbstractLibrary extends AbstractClasspathEntry {
    private static final String ATTRIBUTE_JAVADOC_LOCATION = "javadoc_location";

    private FileReference sourcePath;
    private FileReference javadocPath;
    private FileReference library;

              implementation 'commons-io:commons-io:1.4'
            }

            import org.gradle.plugins.ide.eclipse.model.AbstractClasspathEntry

            eclipse.classpath.file.whenMerged { cp ->
              cp.entries.each {
                if(it instanceof AbstractClasspathEntry) {
                  //some people have workarounds in their builds and configure the component dependency,
                  //just like here:

import org.gradle.api.tasks.TaskDependency;

import java.util.Objects;

/**
 * A classpath entry representing a project dependency.
 */
public class ProjectDependency extends AbstractClasspathEntry {

    private FileReference publication;
    private FileReference publicationSourcePath;
    private FileReference publicationJavadocPath;