org.eclipse.jetty.start.Classpath Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jetty-start Show documentation
The start utility
There is a newer version: 12.0.13
//
//  ========================================================================
//  Copyright (c) 1995-2013 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.start;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.StringTokenizer;
import java.util.Vector;

/**
 * Class to handle CLASSPATH construction
 */
public class Classpath
{

    private final Vector _elements = new Vector();

    public Classpath()
    {
    }

    public Classpath(String initial)
    {
        addClasspath(initial);
    }

    public File[] getElements()
    {
        return _elements.toArray(new File[_elements.size()]);
    }

    public int count()
    {
        return _elements.size();
    }

    public boolean addComponent(String component)
    {
        if ((component != null) && (component.length() > 0))
        {
            try
            {
                File f = new File(component);
                if (f.exists())
                {
                    File key = f.getCanonicalFile();
                    if (!_elements.contains(key))
                    {
                        _elements.add(key);
                        return true;
                    }
                }
            }
            catch (IOException e)
            {
            }
        }
        return false;
    }

    public boolean addComponent(File component)
    {
        if (component != null)
        {
            try
            {
                if (component.exists())
                {
                    File key = component.getCanonicalFile();
                    if (!_elements.contains(key))
                    {
                        _elements.add(key);
                        return true;
                    }
                }
            }
            catch (IOException e)
            {
            }
        }
        return false;
    }

    public boolean addClasspath(String s)
    {
        boolean added = false;
        if (s != null)
        {
            StringTokenizer t = new StringTokenizer(s, File.pathSeparator);
            while (t.hasMoreTokens())
            {
                added |= addComponent(t.nextToken());
            }
        }
        return added;
    }

    public void dump(PrintStream out)
    {
        int i = 0;
        for (File element : _elements)
        {
            out.printf("%2d: %s\n", i++, element.getAbsolutePath());
        }
    }

    @Override
    public String toString()
    {
        StringBuffer cp = new StringBuffer(1024);
        int cnt = _elements.size();
        if (cnt >= 1)
        {
            cp.append(((_elements.elementAt(0))).getPath());
        }
        for (int i = 1; i < cnt; i++)
        {
            cp.append(File.pathSeparatorChar);
            cp.append(((_elements.elementAt(i))).getPath());
        }
        return cp.toString();
    }

    public ClassLoader getClassLoader()
    {
        int cnt = _elements.size();
        URL[] urls = new URL[cnt];
        for (int i = 0; i < cnt; i++)
        {
            try
            {
                urls[i] = _elements.elementAt(i).toURI().toURL();
            }
            catch (MalformedURLException e)
            {
            }
        }

        ClassLoader parent = Thread.currentThread().getContextClassLoader();
        if (parent == null)
        {
            parent = Classpath.class.getClassLoader();
        }
        if (parent == null)
        {
            parent = ClassLoader.getSystemClassLoader();
        }
        return new Loader(urls, parent);
    }

    private static class Loader extends URLClassLoader
    {
        Loader(URL[] urls, ClassLoader parent)
        {
            super(urls, parent);
        }

        @Override
        public String toString()
        {
            return "startJarLoader@" + Long.toHexString(hashCode());
        }
    }



    /**
     * Overlay another classpath, copying its elements into place on this
     * Classpath, while eliminating duplicate entries on the classpath.
     *
     * @param cpOther the other classpath to overlay
     */
    public void overlay(Classpath cpOther)
    {
        for (File otherElement : cpOther._elements)
        {
            if (this._elements.contains(otherElement))
            {
                // Skip duplicate entries
                continue;
            }
            this._elements.add(otherElement);
        }
    }

    public boolean isEmpty()
    {
        return (_elements == null) || (_elements.isEmpty());
    }
}