sigil/common/core/src/org/apache/felix/sigil/config/BldProject.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.felix.sigil.config;


import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeSet;

import org.apache.felix.sigil.core.internal.model.osgi.BundleModelElement;
import org.apache.felix.sigil.core.internal.model.osgi.PackageExport;
import org.apache.felix.sigil.core.internal.model.osgi.PackageImport;
import org.apache.felix.sigil.core.internal.model.osgi.RequiredBundle;
import org.apache.felix.sigil.model.IModelElement;
import org.apache.felix.sigil.model.common.VersionRange;
import org.apache.felix.sigil.model.eclipse.ISigilBundle;
import org.apache.felix.sigil.model.osgi.IBundleModelElement;
import org.apache.felix.sigil.model.osgi.IPackageExport;
import org.apache.felix.sigil.model.osgi.IPackageImport;
import org.apache.felix.sigil.model.osgi.IPackageImport.OSGiImport;
import org.apache.felix.sigil.model.osgi.IRequiredBundle;
import org.osgi.framework.Version;


public class BldProject implements IBldProject, IRepositoryConfig
{
    private static final String OVERRIDE_PREFIX = "sigil.";
    private static final int MAX_HEADER = 10240;
    // cache to avoid loading the same default config for each project
    private static Map<URL, BldConfig> defaultsCache = new HashMap<URL, BldConfig>();
    private static Properties overrides;

    private List<String> sourcePkgs;
    private BldConfig config;
    private BldConverter convert;
    private BundleModelElement requirements;
    private File baseDir;
    private URI loc;
    private Properties packageDefaults;
    private TreeSet<String> packageWildDefaults;
    private long lastModified;


    /* package */BldProject( URI relLoc )
    {
        config = new BldConfig();
        convert = new BldConverter( config );
        loc = new File( "." ).toURI().resolve( relLoc ).normalize();
        File f = new File( loc );
        lastModified = f.lastModified();
        baseDir = f.getParentFile();
    }


    /* package */void load() throws IOException
    {
        // allow System property overrides, e.g.
        // ANT_OPTS='-Dsigil.option\;addMissingImports=false' ant
        config.merge( getOverrides() );

        InputStream in = null;
        try
        {
            in = loc.toURL().openStream();
            BufferedInputStream bis = new BufferedInputStream( in );
            bis.mark( MAX_HEADER );
            readHeader( bis );
            bis.reset();

            Properties p = new Properties();
            p.load( bis );
            config.merge( p );

            Properties unknown = config.getUnknown();
            if ( !unknown.isEmpty() )
                System.err.println( "WARN: unknown keys " + unknown.keySet() + " in " + loc );

            loadDefaults( p );
            requirements = parseRequirements();
        }
        finally
        {
            if ( in != null )
            {
                in.close();
            }
        }
    }


    /* package */void loadDefaults( Properties p ) throws IOException
    {
        BldConfig c = loadDefaults( p, baseDir, null );
        config.setDefault( c );

        Properties options = config.getProps( null, BldConfig.P_OPTION );

        if ( !options.containsKey( BldAttr.OPTION_ADD_IMPORTS ) )
            c.setProp( null, BldConfig.P_OPTION, BldAttr.OPTION_ADD_IMPORTS, "true" );

        // default omitUnusedImports option depends on number of bundles...
        // we set it here to avoid it being written by save(),
        // but as this may alter cached defaults, once set we have to reset it
        // for each project.

        boolean omitSet = options.containsKey( "__omit_set__" );
        boolean multiple = getBundleIds().size() > 1;

        if ( multiple || omitSet )
        {
            if ( !options.containsKey( BldAttr.OPTION_OMIT_IMPORTS ) || omitSet )
            {
                c.setProp( null, BldConfig.P_OPTION, BldAttr.OPTION_OMIT_IMPORTS, multiple + "" );
                c.setProp( null, BldConfig.P_OPTION, "__omit_set__", "true" );
            }
        }
    }


    private synchronized BldConfig loadDefaults( Properties props, File base, BldConfig dflt ) throws IOException
    {
        boolean cached = false;
        String defaults = props.getProperty( BldConfig.S_DEFAULTS, "-" + IBldProject.PROJECT_DEFAULTS );

        if ( base != null && defaults.length() > 0 )
        {
            boolean ignore = defaults.startsWith( "-" );

            if ( ignore )
                defaults = defaults.substring( 1 );

            try
            {
                File file = new File( base, defaults ).getCanonicalFile();
                URL url = file.toURL();

                if ( dflt == null )
                {
                    dflt = defaultsCache.get( url );
                    if ( dflt != null )
                        return dflt;

                    dflt = new BldConfig();
                    defaultsCache.put( url, dflt );
                    cached = true;
                }

                Properties p = new Properties();
                // FIXME stream not closed
                p.load( url.openStream() );
                dflt.merge( p );

                ignore = false;
                loadDefaults( p, file.getParentFile(), dflt );
            }
            catch ( IOException e )
            {
                if ( !ignore )
                    throw e;
            }
        }

        if ( dflt == null )
            return new BldConfig();

        if ( cached )
        {
            Properties unknown = dflt.getUnknown();
            if ( !unknown.isEmpty() )
                System.err.println( "WARN: unknown keys " + unknown.keySet() + " in defaults for " + loc );
        }

        return dflt;
    }


    private static Properties getOverrides()
    {
        if ( overrides == null )
        {
            overrides = new Properties();
            Properties sysProps = System.getProperties();

            for ( Object okey : sysProps.keySet() )
            {
                String key = ( String ) okey;
                if ( key.startsWith( OVERRIDE_PREFIX ) )
                {
                    overrides.setProperty( key.substring( OVERRIDE_PREFIX.length() ), sysProps.getProperty( key ) );
                }
            }
        }

        return overrides;
    }


    private void readHeader( InputStream in ) throws IOException
    {
        BufferedReader r = new BufferedReader( new InputStreamReader( in ) );
        StringBuffer header = new StringBuffer();
        String line;
        while ( ( line = r.readLine() ) != null )
        {
            if ( line.startsWith( "#" ) )
            {
                header.append( line );
                header.append( "\n" );
            }
            else
            {
                config.setComment( header.toString() );
                break;
            }
        }
    }


    public File resolve( String path )
    {
        File file = new File( path );
        if ( !file.isAbsolute() )
        {
            // can't use loc.resolve(value), as value may not be valid URI.
            file = new File( baseDir, path );
        }
        return file;
    }


    public String getVersion()
    {
        String version = config.getString( null, BldConfig.S_VERSION );
        return version == null ? "0" : version;
    }


    public IBundleModelElement getDependencies()
    {
        IBundleModelElement dependencies = new BundleModelElement();

        for ( IModelElement element : getRequirements().children() )
        {
            if ( element instanceof IPackageImport )
            {
                IPackageImport import1 = ( IPackageImport ) element;
                if ( !import1.isDependency() )
                    continue;

                IPackageImport pi = ( IPackageImport ) ( element.clone() );
                pi.setParent( null );
                dependencies.addImport( pi );
            }
            else
            {
                IRequiredBundle rb = ( IRequiredBundle ) ( element.clone() );
                rb.setParent( null );
                dependencies.addRequiredBundle( rb );
            }
        }

        return dependencies;
    }


    private IBundleModelElement getRequirements()
    {
        return requirements;
    }


    /*
     * private boolean globMatch(String pkg, Set<String> set) { // exact match
     * if (set.contains(pkg)) return true;
     * 
     * // org.foo.bar matches org.foo. for (String glob : set) { if
     * (glob.matches(pkg)) { return true; } }
     * 
     * return false; }
     */

    /**
     * set internal OSGiImport and isDependency flags, based on external
     * resolution= attribute.
     * 
     * OSGiImport: AUTO ALWAYS NEVER dependency: default - compile !dependency:
     * auto runtime ignore
     * 
     */
    private void setResolve( IPackageImport pi, String resolve ) throws IOException
    {
        if ( pi.isOptional() )
            pi.setDependency( false );

        if ( BldAttr.RESOLVE_COMPILE.equals( resolve ) )
        {
            if ( pi.isOptional() )
                pi.setDependency( true );
            else
                pi.setOSGiImport( OSGiImport.NEVER );
        }
        else if ( BldAttr.RESOLVE_RUNTIME.equals( resolve ) )
        {
            pi.setDependency( false );
            pi.setOSGiImport( OSGiImport.ALWAYS );
        }
        else if ( BldAttr.RESOLVE_AUTO.equals( resolve ) )
        {
            pi.setDependency( false );
        }
        else if ( BldAttr.RESOLVE_IGNORE.equals( resolve ) )
        {
            pi.setDependency( false );
            pi.setOSGiImport( OSGiImport.NEVER );
        }
        else if ( resolve != null )
        {
            throw new IOException( "Bad attribute value: " + BldAttr.RESOLVE_ATTRIBUTE + "=" + resolve );
        }
    }


    /**
     * get external resolve= attribute from internal PackageImport flags. This
     * is called from BldConverter.setBundle().
     */
    public static String getResolve( IPackageImport pi, boolean isDependency )
    {
        OSGiImport osgiImport = pi.getOSGiImport();
        String resolve = null;

        if ( isDependency )
        {
            if ( osgiImport.equals( OSGiImport.NEVER ) || pi.isOptional() )
                resolve = BldAttr.RESOLVE_COMPILE;
        }
        else
        {
            switch ( osgiImport )
            {
                case ALWAYS:
                    resolve = BldAttr.RESOLVE_RUNTIME;
                    break;
                case AUTO:
                    resolve = BldAttr.RESOLVE_AUTO;
                    break;
                case NEVER:
                    resolve = BldAttr.RESOLVE_IGNORE;
                    break;
            }
        }
        return resolve;
    }


    public String getDefaultPackageVersion( String name )
    {
        if ( packageDefaults == null )
        {
            packageDefaults = config.getProps( null, BldConfig.P_PACKAGE_VERSION );
            packageWildDefaults = new TreeSet<String>();

            for ( Object key : packageDefaults.keySet() )
            {
                String pkg = ( String ) key;
                if ( pkg.endsWith( "*" ) )
                {
                    packageWildDefaults.add( pkg.substring( 0, pkg.length() - 1 ) );
                }
            }
        }

        String version = packageDefaults.getProperty( name );

        if ( version == null )
        {
            for ( String pkg : packageWildDefaults )
            {
                if ( name.startsWith( pkg ) )
                {
                    version = packageDefaults.getProperty( pkg + "*" );
                    // break; -- don't break, as we want the longest match
                }
            }
        }

        return version;
    }


    private synchronized BundleModelElement parseRequirements() throws IOException
    {
        BundleModelElement reqs = new BundleModelElement();

        List<String> sourceContents = getSourcePkgs();
        HashSet<String> exports = new HashSet<String>();

        parseExports(reqs, exports);
        
        parseImports(reqs, sourceContents, exports);
        
        parseRequires(reqs);
        
        return reqs;
    }


    /**
     * @param reqs
     * @param exports
     */
    private void parseExports( BundleModelElement reqs, HashSet<String> exports )
    {
        for ( IBldBundle bundle : getBundles() )
        {
            for ( IPackageExport export : bundle.getExports() )
            {
                exports.add( export.getPackageName() );
            }
        }
    }


    /**
     * @param reqs
     * @throws IOException 
     */
    private void parseRequires( BundleModelElement reqs ) throws IOException
    {
        Map<String, Map<String, String>> requires = config.getMap( null, BldConfig.M_REQUIRES );
        Properties bundleDefaults = config.getProps( null, BldConfig.P_BUNDLE_VERSION );

        if ( requires != null )
        {
            for ( String name : requires.keySet() )
            {
                Map<String, String> attr = requires.get( name );
                String versions = attr.containsKey( BldAttr.VERSION_ATTRIBUTE ) ? attr.get( BldAttr.VERSION_ATTRIBUTE )
                    : bundleDefaults.getProperty( name );
                String resolution = attr.get( BldAttr.RESOLUTION_ATTRIBUTE );

                RequiredBundle rb = new RequiredBundle();
                rb.setSymbolicName( name );
                rb.setVersions( VersionRange.parseVersionRange( versions ) );

                if ( BldAttr.RESOLUTION_OPTIONAL.equals( resolution ) )
                {
                    rb.setOptional( true );
                }
                else if ( resolution != null )
                {
                    throw new IOException( "Bad attribute value: " + BldAttr.RESOLUTION_ATTRIBUTE + "=" + resolution );
                }

                reqs.addRequiredBundle( rb );
            }
        }

        for ( IBldBundle bundle : getBundles() )
        {
            IRequiredBundle fh = bundle.getFragmentHost();
            if ( fh != null )
                reqs.addRequiredBundle( fh );
        }
    }


    /**
     * @param reqs 
     * @param exports 
     * @param sourceContents 
     * @throws IOException 
     * 
     */
    private void parseImports(BundleModelElement reqs, List<String> sourceContents, HashSet<String> exports) throws IOException
    {
        Map<String, Map<String, String>> imports = config.getMap( null, BldConfig.M_IMPORTS );

        for ( String name : imports.keySet() )
        {
            Map<String, String> attr = imports.get( name );

            String resolve = attr.get( BldAttr.RESOLVE_ATTRIBUTE );
            String resolution = attr.get( BldAttr.RESOLUTION_ATTRIBUTE );
            String versions = attr.containsKey( BldAttr.VERSION_ATTRIBUTE ) ? attr.get( BldAttr.VERSION_ATTRIBUTE )
                : getDefaultPackageVersion( name );

            PackageImport pi = new PackageImport();
            pi.setPackageName( name );

            // avoid dependency on self-exports
            // XXX: BldConverter.setBundle contains similar logic
            if ( exports.contains( name ) && ( sourceContents.contains( name ) || sourceContents.isEmpty() ) )
            {
                pi.setDependency( false );
                if ( versions == null )
                    versions = getVersion();
            }

            if ( !checkVersionRange( versions ) )
            {
                throw new IOException( "Failed to parse version range for " + resolve
                    + " missing \"'s around version range?" );
            }

            pi.setVersions( VersionRange.parseVersionRange( versions ) );

            if ( BldAttr.RESOLUTION_OPTIONAL.equals( resolution ) )
            {
                pi.setOptional( true );
            }
            else if ( resolution != null )
            {
                throw new IOException( "Bad attribute value: " + BldAttr.RESOLUTION_ATTRIBUTE + "=" + resolution );
            }

            setResolve( pi, resolve );

            reqs.addImport( pi );
        }
    }


    private boolean checkVersionRange( String versions )
    {
        if ( versions == null || versions.length() == 0 )
        {
            return true;
        }
        else
        {
            switch ( versions.charAt( 0 ) )
            {
                case '(':
                case '[':
                    switch ( versions.charAt( versions.length() - 1 ) )
                    {
                        case ')':
                        case ']':
                            return true;
                        default:
                            return false;
                    }
                default:
                    return true;
            }
        }
    }


    public List<String> getBundleIds()
    {
        List<String> ids = config.getList( null, BldConfig.C_BUNDLES );
        if ( ids == null )
            return Collections.emptyList();
        return ids;
    }


    public List<IBldBundle> getBundles()
    {
        ArrayList<IBldBundle> list = new ArrayList<IBldBundle>();

        for ( String id : getBundleIds() )
        {
            list.add( new BldBundle( id ) );
        }

        return list;
    }


    // Implement IBldConfig: getRepositoryConfig

    public Map<String, Properties> getRepositoryConfig()
    {
        HashMap<String, Properties> map = new HashMap<String, Properties>();

        final Map<String, String> env = System.getenv();
        final Properties props = new Properties();
        try
        {
            // supports ${.} and ${..} expansions
            props.setProperty( ".", resolve( "." ).getCanonicalPath() );
            props.setProperty( "..", resolve( ".." ).getCanonicalPath() );
        }
        catch ( IOException e )
        {
        }

        for ( String name : config.getList( null, BldConfig.C_REPOSITORIES ) )
        {
            Properties repo = config.getProps( null, name );

            for ( Object k : repo.keySet() )
            {
                String key = ( String ) k;
                String value = repo.getProperty( key );

                String expand = BldUtil.expand( value, new Properties()
                {
                    public String getProperty( String name )
                    {
                        return props.getProperty( name, env.get( name ) );
                    }
                } );

                if ( !value.equals( expand ) )
                {
                    value = expand;
                    repo.setProperty( key, value );
                }

                // backwards compatible support before ${.} and ${..} was added
                if ( value.startsWith( "./" ) || value.startsWith( "../" ) )
                {
                    try
                    {
                        // need canonical path, to normalise
                        value = resolve( value ).getCanonicalPath();
                    }
                    catch ( IOException e )
                    {
                    }
                    repo.setProperty( key, value );
                }
            }

            map.put( name, repo );
        }
        return map;
    }


    public Properties getOptions()
    {
        return config.getProps( null, BldConfig.P_OPTION );
    }


    public Properties getDefaultPackageVersions()
    {
        return config.getProps( null, BldConfig.P_PACKAGE_VERSION );
    }


    public ISigilBundle getDefaultBundle()
    {
        List<String> bundles = getBundleIds();
        if ( bundles.isEmpty() )
            return null;

        String id = bundles.get( 0 );
        return getSigilBundle( id );
    }


    public ISigilBundle getSigilBundle( String id )
    {
        BldBundle bundle = new BldBundle( id );
        return convert.getBundle( id, bundle );
    }


    public void setDefaultBundle( ISigilBundle bundle )
    {
        setSigilBundle( null, bundle );
    }


    public void setSigilBundle( String id, ISigilBundle bundle )
    {
        List<String> ids = getBundleIds();

        if ( ids.isEmpty() )
        {
            ArrayList<String> list = new ArrayList<String>();
            list.add( id == null ? bundle.getBundleInfo().getSymbolicName() : id );
            config.setList( null, BldConfig.C_BUNDLES, list );
        }
        else if ( id == null )
        {
            id = ids.get( 0 );
        }
        else if ( !ids.contains( id ) )
        {
            List<String> list = config.getList( null, BldConfig.C_BUNDLES );
            list.add( id );
            config.setList( null, BldConfig.C_BUNDLES, list );
        }

        if ( ids.size() == 1 )
            id = null; // don't prefix default bundle with id

        convert.setBundle( id, bundle );
    }


    public void save() throws IOException
    {
        saveAs( new File( loc ) );
    }


    public void saveAs( File path ) throws IOException
    {
        File part = new File( path.getPath() + ".part" );
        saveTo( new FileOutputStream( ( part ) ) );

        path.delete();
        if ( !part.renameTo( path ) )
            throw new IOException( "failed to rename " + part + " to " + path );
    }


    public void saveTo( OutputStream out )
    {
        PrintWriter writer = new PrintWriter( new OutputStreamWriter( out ) );
        config.write( writer );
        writer.close();
    }


    public List<String> getSourceDirs()
    {
        List<String> list = config.getList( null, BldConfig.L_SRC_CONTENTS );
        return list != null ? list : Collections.<String> emptyList();
    }


    public List<String> getSourcePkgs()
    {
        if ( sourcePkgs == null )
        {
            sourcePkgs = new ArrayList<String>();
            for ( String src : getSourceDirs() )
            {
                File dir = resolve( src );
                if ( !dir.isDirectory() )
                {
                    System.err.println( "WARN: sourcedir does not exist: " + dir );
                    continue;
                    // throw new RuntimeException("sourcedir: " + dir +
                    // " : is not a directory.");
                }
                findSrcPkgs( dir, null, sourcePkgs );
            }
        }

        return sourcePkgs;
    }


    private void findSrcPkgs( File dir, String pkg, List<String> result )
    {
        ArrayList<File> dirs = new ArrayList<File>();
        boolean found = false;

        for ( String name : dir.list() )
        {
            if ( name.endsWith( ".java" ) )
            {
                found = true;
            }
            else if ( !name.equals( ".svn" ) )
            {
                File d = new File( dir, name );
                if ( d.isDirectory() )
                    dirs.add( d );
            }
        }

        if ( pkg == null )
        {
            pkg = "";
        }
        else if ( pkg.equals( "" ) )
        {
            pkg = dir.getName();
        }
        else
        {
            pkg = pkg + "." + dir.getName();
        }

        if ( found )
            result.add( pkg );

        for ( File d : dirs )
            findSrcPkgs( d, pkg, result );
    }

    /**
     * BldBundle
     * 
     */
    class BldBundle implements IBldBundle
    {
        private String id;


        public BldBundle( String id )
        {
            this.id = id;
        }


        public File resolve( String path )
        {
            return BldProject.this.resolve( path );
        }


        private String getString( String key )
        {
            return config.getString( id, key );
        }


        private boolean getBoolean( String key )
        {
            return Boolean.parseBoolean( getString( key ) );
        }


        private List<String> getList( String key )
        {
            List<String> list = config.getList( id, key );
            return list != null ? list : Collections.<String> emptyList();
        }


        private Map<String, Map<String, String>> getMap( String key )
        {
            Map<String, Map<String, String>> map = config.getMap( id, key );
            return map != null ? map : Collections.<String, Map<String, String>> emptyMap();
        }


        public String getActivator()
        {
            return getString( BldConfig.S_ACTIVATOR );
        }


        public String getId()
        {
            String name = getString( "id" );
            return name != null ? name : id;
        }


        public String getVersion()
        {
            String ver = getString( BldConfig.S_VERSION );
            if ( ver == null )
            {
                ver = BldProject.this.getVersion();
            }
            return ver;
        }


        public String getSymbolicName()
        {
            String name = getString( BldConfig.S_SYM_NAME );
            return name != null ? name : getId();
        }


        public boolean isSingleton()
        {
            return getBoolean( BldConfig.S_SINGLETON );
        }


        public List<IPackageExport> getExports()
        {
            ArrayList<IPackageExport> list = new ArrayList<IPackageExport>();
            Map<String, Map<String, String>> exports = getMap( BldConfig.M_EXPORTS );

            if ( exports != null )
            {
                for ( String name : exports.keySet() )
                {
                    Map<String, String> attrs = exports.get( name );
                    PackageExport pkgExport = new PackageExport();
                    pkgExport.setPackageName( name );

                    String version = attrs.get( BldAttr.VERSION_ATTRIBUTE );
                    // only default export version from local packages
                    if ( version == null && ( getSourcePkgs().isEmpty() || getSourcePkgs().contains( name ) ) )
                    {
                        version = getVersion();
                    }

                    if ( version != null )
                        pkgExport.setVersion( new Version( version ) );

                    list.add( pkgExport );
                }
            }

            return list;
        }


        public List<IPackageImport> getImports()
        {
            ArrayList<IPackageImport> list = new ArrayList<IPackageImport>();

            for ( IPackageImport import1 : getRequirements().childrenOfType( IPackageImport.class ) )
            {
                list.add( import1 );
            }

            return list;
        }


        public List<IRequiredBundle> getRequires()
        {
            ArrayList<IRequiredBundle> list = new ArrayList<IRequiredBundle>();
            list.addAll( Arrays.asList( getRequirements().childrenOfType( IRequiredBundle.class ) ) );

            for ( IBldBundle bundle : getBundles() )
            {
                IRequiredBundle fh = bundle.getFragmentHost();
                if ( fh != null )
                    list.remove( fh );
            }

            return list;
        }


        public IRequiredBundle getFragmentHost()
        {
            IRequiredBundle fragment = null;
            Map<String, Map<String, String>> fragments = getMap( BldConfig.M_FRAGMENT );
            if ( fragments != null )
            {
                for ( String name : fragments.keySet() )
                {
                    Map<String, String> attr = fragments.get( name );
                    String versions = attr.isEmpty() ? null : attr.get( BldAttr.VERSION_ATTRIBUTE );
                    fragment = new RequiredBundle();
                    fragment.setSymbolicName( name );
                    fragment.setVersions( VersionRange.parseVersionRange( versions ) );
                    break;
                }
            }

            return fragment;
        }


        public Map<String, Map<String, String>> getLibs()
        {
            Map<String, Map<String, String>> libs = getMap( BldConfig.M_LIBS );
            return ( libs != null ) ? libs : Collections.<String, Map<String, String>> emptyMap();
        }


        public List<String> getContents()
        {
            return getList( BldConfig.L_CONTENTS );
        }


        public List<String> getDownloadContents()
        {
            return getList( BldConfig.L_DL_CONTENTS );
        }


        public List<String> getComposites()
        {
            ArrayList<String> list = new ArrayList<String>();
            for ( String composite : getList( BldConfig.L_COMPOSITES ) )
            {
                list.add( composite );
            }

            return list;
        }


        public Map<String, String> getResources()
        {
            HashMap<String, String> map = new HashMap<String, String>();
            List<String> resources = getList( BldConfig.L_RESOURCES );

            if ( resources != null )
            {
                for ( String resource : resources )
                {
                    String[] paths = resource.split( "=", 2 );
                    String fsPath = ( paths.length > 1 ? paths[1] : "" );
                    map.put( paths[0], fsPath );
                }
            }
            return map;
        }


        public Properties getHeaders()
        {
            Properties headers = config.getProps( id, BldConfig.P_HEADER );
            return headers;
        }

    }


    public long getLastModified()
    {
        return lastModified;
    }

}