Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright 2005, JBoss Inc., and individual contributors as indicated
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.jboss.osgi.framework.internal;
 
 import static org.osgi.framework.Constants.FRAMEWORK_BOOTDELEGATION;
 import static org.osgi.framework.Constants.FRAMEWORK_BUNDLE_PARENT;
 import static org.osgi.framework.Constants.FRAMEWORK_BUNDLE_PARENT_BOOT;
 import static org.osgi.framework.Constants.FRAMEWORK_BUNDLE_PARENT_EXT;
 import static org.osgi.framework.Constants.FRAMEWORK_SYSTEMPACKAGES;
 import static org.osgi.framework.Constants.FRAMEWORK_SYSTEMPACKAGES_EXTRA;
 
 import java.util.List;
 import java.util.Set;
 
A plugin manages the Framework's system packages.

Author(s):
thomas.diesler@jboss.com
Since:
18-Aug-2009
 
 
     // Provide logging
     final Logger log = Logger.getLogger(DefaultSystemPathsProvider.class);
 
     private final FrameworkBuilder frameworkBuilder;
     // The derived combination of all system packages
     private Set<StringsystemPackages = new LinkedHashSet<String>();
     // The boot delegation packages
     private Set<StringbootDelegationPackages = new LinkedHashSet<String>();
     // The framework packages
     private Set<StringframeworkPackages = new LinkedHashSet<String>();
 
     private Set<StringcachedBootDelegationPaths;
     private Set<StringcachedFrameworkPaths;
     private PathFilter cachedFrameworkFilter;
     private Set<StringcachedSystemPaths;
     private PathFilter cachedSystemFilter;
 
     static void addService(ServiceTarget serviceTargetFrameworkBuilder frameworkBuilder) {
         SystemPathsProvider service = new DefaultSystemPathsProvider(frameworkBuilder);
         ServiceBuilder<SystemPathsProviderbuilder = serviceTarget.addService(.service);
         builder.setInitialMode(.);
         builder.install();
     }
 
     private DefaultSystemPathsProvider(FrameworkBuilder frameworkBuilder) {
         this. = frameworkBuilder;
     }
 
     @Override
     public void start(StartContext contextthrows StartException {
         super.start(context);
 
         // Initialize the framework packages
 
         String systemPackagesProp = (String.getProperty();
         if (systemPackagesProp != null) {
             .addAll(packagesAsList(systemPackagesProp));
         } else {
             // The default system packages
            .addAll();
        }
        // Add the extra system packages
        if (extraPackages != null)
            .addAll(packagesAsList(extraPackages));
        // Initialize the boot delegation package names
        String bootDelegationProp = (String.getProperty();
        if (bootDelegationProp != null) {
            String[] packageNames = bootDelegationProp.split(",");
            for (String packageName : packageNames) {
                .add(packageName);
            }
        } else {
            .add("sun.*");
            .add("com.sun.*");
        }
    }
    @Override
    public SystemPathsProvider getValue() {
        return this;
    }
    @Override
    public Set<StringgetBootDelegationPackages() {
        assertInitialized();
        return Collections.unmodifiableSet();
    }
    @Override
        assertInitialized();
        if ( == null) {
            MultiplePathFilterBuilder builder = PathFilters.multiplePathFilterBuilder(false);
            for (String packageName : getBootDelegationPackages()) {
                if (packageName.equals("*")) {
                    if (doFrameworkPackageDelegation()) {
                        builder.addFilter(PathFilters.acceptAll(), true);
                    } else {
                        builder.addFilter(PathFilters.all(PathFilters.acceptAll(), PathFilters.not(getFrameworkFilter())), true);
                    }
                } else if (packageName.endsWith(".*")) {
                    packageName = packageName.substring(0, packageName.length() - 2);
                    builder.addFilter(PathFilters.isChildOf(packageName.replace('.''/')), true);
                } else {
                    builder.addFilter(PathFilters.is(packageName.replace('.''/')), true);
                }
            }
             = builder.create();
            .debugf("BootDelegationFilter: %s");
        }
        return ;
    }
    @Override
    public Set<StringgetBootDelegationPaths() {
        assertInitialized();
        if ( == null) {
            Set<Stringresult = new LinkedHashSet<String>();
            boolean hasBootDelegationWildcards = false;
            for (String packageName : getBootDelegationPackages()) {
                if (packageName.endsWith("*")) {
                    hasBootDelegationWildcards = true;
                    break;
                }
            }
            if (hasBootDelegationWildcards == true) {
                PathFilter bootDelegationFilter = getBootDelegationFilter();
                for (String path : .) {
                    if (bootDelegationFilter.accept(path)) {
                        result.add(path);
                    }
                }
            } else {
                for (String packageName : getBootDelegationPackages()) {
                    result.add(packageName.replace('.''/'));
                }
            }
             = Collections.unmodifiableSet(result);
            .debugf("BootDelegationPaths: %s");
        }
        return ;
    }
    @Override
    public Set<StringgetSystemPackages() {
        assertInitialized();
        return Collections.unmodifiableSet();
    }
    @Override
    public PathFilter getSystemFilter() {
        assertInitialized();
        if ( == null) {
            MultiplePathFilterBuilder builder = PathFilters.multiplePathFilterBuilder(false);
            Set<Stringpaths = new LinkedHashSet<String>();
            for (String packageSpec : getSystemPackages()) {
                int index = packageSpec.indexOf(';');
                if (index > 0) {
                    packageSpec = packageSpec.substring(0, index);
                }
                String path = packageSpec.replace('.''/');
                paths.add(path);
            }
            builder.addFilter(PathFilters.in(paths), true);
             = builder.create();
            .debugf("SystemFilter: %s");
        }
        return ;
    }
    @Override
    public Set<StringgetSystemPaths() {
        assertInitialized();
        if ( == null) {
            Set<Stringresult = new LinkedHashSet<String>();
            for (String packageSpec : getSystemPackages()) {
                int index = packageSpec.indexOf(';');
                if (index > 0) {
                    packageSpec = packageSpec.substring(0, index);
                }
                String path = packageSpec.replace('.''/');
                result.add(path);
            }
             = Collections.unmodifiableSet(result);
            .debugf("SystemPaths: %s");
        }
        return ;
    }
    private Set<StringgetFrameworkPackages() {
        return Collections.unmodifiableSet();
    }
    private Set<StringgetFrameworkPaths() {
        if ( == null) {
            Set<Stringpaths = new LinkedHashSet<String>();
            for (String packageSpec : getFrameworkPackages()) {
                int index = packageSpec.indexOf(';');
                if (index > 0) {
                    packageSpec = packageSpec.substring(0, index);
                }
                paths.add(packageSpec.replace('.''/'));
            }
             = Collections.unmodifiableSet(paths);
            .debugf("FrameworkPaths: %s");
        }
        return ;
    }
    private PathFilter getFrameworkFilter() {
        assertInitialized();
        if ( == null) {
             = PathFilters.in(getFrameworkPaths());
            .debugf("FrameworkFilter: %s");
        }
        return ;
    }
    private boolean doFrameworkPackageDelegation() {
        if (property == null) {
            property = ;
        }
        boolean allBootDelegation = getBootDelegationPackages().contains("*");
        return !(allBootDelegation && (.equals(property) || .equals(property)));
    }
    private List<StringpackagesAsList(String sysPackages) {
        List<Stringresult = new ArrayList<String>();
        for (String name : sysPackages.split(",")) {
            name = name.trim();
            if (name.length() > 0)
                result.add(name);
        }
        return result;
    }
    private void assertInitialized() {
        if (.isEmpty())
            throw new IllegalStateException(getClass().getSimpleName() + " not initialized");
    }
New to GrepCode? Check out our FAQ X