org.eclipse.jst.common.internal.modulecore.ClasspathContainerVirtualComponent.java Source code

Introduction

Here is the source code for org.eclipse.jst.common.internal.modulecore.ClasspathContainerVirtualComponent.java

Source

/*******************************************************************************
 * Copyright (c) 2009 Red Hat and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Red Hat - Initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.common.internal.modulecore;

import java.io.File;
import java.util.ArrayList;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.wst.common.componentcore.internal.resources.AbstractResourceListVirtualComponent;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualFile;
import org.eclipse.wst.common.componentcore.internal.resources.VirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualFile;
import org.eclipse.wst.common.componentcore.resources.IVirtualFolder;
import org.eclipse.wst.common.componentcore.resources.IVirtualResource;

public class ClasspathContainerVirtualComponent extends AbstractResourceListVirtualComponent {
    public static final String CLASSPATH = "classpath"; //$NON-NLS-1$
    public static final String CON = "con"; //$NON-NLS-1$
    public static final String CLASSPATH_CON = CLASSPATH + Path.SEPARATOR + CON;
    private String containerPath;
    private IClasspathEntry[] containerEntries;
    private IClasspathContainer container;
    private boolean initialized = false;
    private Object initLock = new Object();

    public ClasspathContainerVirtualComponent(IProject p, IVirtualComponent referencingComponent,
            String containerPath) {
        super(p, referencingComponent);
        this.containerPath = containerPath;
    }

    private void init() {
        synchronized (initLock) {
            if (initialized) {
                return;
            }
        }
        try {
            IClasspathContainer localContainer = JavaCore.getClasspathContainer(new Path(containerPath),
                    JavaCore.create(project));
            IClasspathEntry[] localcontainerEntries = null;
            if (localContainer != null) {
                localcontainerEntries = localContainer.getClasspathEntries();
            } else {
                localcontainerEntries = new IClasspathEntry[] {};
            }
            synchronized (initLock) {
                if (initialized) {
                    return;
                }
                container = localContainer;
                containerEntries = localcontainerEntries;
            }
        } catch (JavaModelException jme) {
            // eat it
        } finally {
            synchronized (initLock) {
                initialized = true;
            }
        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (!super.equals(o)) {
            return false;
        }
        ClasspathContainerVirtualComponent other = (ClasspathContainerVirtualComponent) o;
        return containerPath == null ? other.containerPath == null : containerPath.equals(other.containerPath);
    }

    @Override
    public int hashCode() {
        return super.hashCode() + (containerPath == null ? 0 : containerPath.hashCode());
    }

    public String getContainerPath() {
        return containerPath;
    }

    @Override
    public String getId() {
        return CLASSPATH_CON + Path.SEPARATOR + containerPath;
    }

    @Override
    protected String getFirstIdSegment() {
        // Do not call
        return null;
    }

    public IClasspathContainer getClasspathContainer() {
        init();
        return container;
    }

    private IClasspathEntry[] getEntries() {
        init();
        return containerEntries;
    }

    public String getClasspathContainerPath() {
        return containerPath;
    }

    @Override
    public IVirtualFolder getRootFolder() {
        IVirtualFolder folder = new VirtualFolder(project, new Path("/")) { //$NON-NLS-1$
            @Override
            public IVirtualResource[] members(int memberFlags) throws CoreException {
                IClasspathEntry[] entries = getEntries();
                ArrayList<IVirtualFile> jars = new ArrayList<IVirtualFile>();
                for (IClasspathEntry entry : entries) {
                    if (entry.getEntryKind() == IClasspathEntry.CPE_LIBRARY) {
                        File f = entry.getPath().toFile();
                        jars.add(new AbsoluteVirtualFile(getProject(), new Path("/"), f)); //$NON-NLS-1$
                    }
                }
                return jars.toArray(new IVirtualFile[jars.size()]);
            }
        };
        return folder;
    }

    protected class AbsoluteVirtualFile extends VirtualFile {
        private File file;

        public AbsoluteVirtualFile(IProject aComponentProject, IPath aRuntimePath, File absoluteFile) {
            super(aComponentProject, aRuntimePath, null);
            this.file = absoluteFile;
        }

        @Override
        public Object getAdapter(Class adapter) {
            if (File.class.equals(adapter))
                return file;
            return null;
        }
    }

    @Override
    protected IContainer[] getUnderlyingContainers() {
        // do not implement, overriding key method members(int)
        return new IContainer[] {};
    }

    @Override
    protected IResource[] getLooseResources() {
        // do not implement, overriding key method members(int)
        return new IResource[] {};
    }
}