Best Java code snippets using org.apache.xbean.osgi.bundle.util.BundleDescription.<init> (Showing top 13 results out of 315)

private void initialize() {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  List<BundleDescription.ImportPackage> imports = description.getExternalImports();
  for (BundleDescription.ImportPackage packageImport : imports) {
    String packageName = packageImport.getName();
    ExportedPackage[] exports = packageAdmin.getExportedPackages(packageName);
    Bundle wiredBundle = isWired(bundle, exports);
    if (wiredBundle != null) {
      wiredImportedPackageNames.add(packageName.replace('.', '/'));
      break;
    }
  }
}

private void initialize() {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  List<BundleDescription.ImportPackage> imports = description.getExternalImports();
  for (BundleDescription.ImportPackage packageImport : imports) {
    String packageName = packageImport.getName();
    ExportedPackage[] exports = packageAdmin.getExportedPackages(packageName);
    Bundle wiredBundle = isWired(bundle, exports);
    if (wiredBundle != null) {
      wiredImportedPackageNames.add(packageName.replace('.', '/'));
      break;
    }
  }
}

private void initialize() {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  List<BundleDescription.ImportPackage> imports = description.getExternalImports();
  for (BundleDescription.ImportPackage packageImport : imports) {
    String packageName = packageImport.getName();
    ExportedPackage[] exports = packageAdmin.getExportedPackages(packageName);
    Bundle wiredBundle = isWired(bundle, exports);
    if (wiredBundle != null) {
      wiredImportedPackageNames.add(packageName.replace('.', '/'));
      break;
    }
  }
}

private void scanRequireBundles(Collection<String> classes, Bundle bundle) {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  List<RequireBundle> requiredBundleList = description.getRequireBundle();
  for (RequireBundle requiredBundle : requiredBundleList) {
    RequiredBundle[] requiredBundles = packageAdmin.getRequiredBundles(requiredBundle.getName());
    Bundle wiredBundle = isWired(bundle, requiredBundles);
    if (wiredBundle != null) {
      BundleDescription wiredBundleDescription = new BundleDescription(wiredBundle.getHeaders());
      List<ExportPackage> exportPackages = wiredBundleDescription.getExportPackage();
      Set<String> exportedPackageNames = new HashSet<String>();
      for (ExportPackage exportPackage : exportPackages) {
        exportedPackageNames.add(exportPackage.getName());
      }
      Set<String> allClasses = findAllClasses(wiredBundle, discoveryFilter, exportedPackageNames);
      classes.addAll(allClasses);
    }
  }
}

private Set<PackageBundlePair> getDynamicImportingPairs(PackageAdmin packageAdmin, Bundle bundle, Set<String> wiredPackages) {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  
  Set<PackageBundlePair> dynamicImportingPairs = new HashSet<PackageBundlePair>();
  
  if (!description.getDynamicImportPackage().isEmpty()) {
    for (Bundle b : bundle.getBundleContext().getBundles()) {
      
      // find the packages that importing from the bundle
      ExportedPackage[] exportedPackages = packageAdmin.getExportedPackages(b);
      if (exportedPackages != null) {
        for (ExportedPackage exportedPackage : exportedPackages) {
          if (wiredPackages.contains(toString(exportedPackage))) {
            continue;
          }
          Bundle[] importingBundles = exportedPackage.getImportingBundles();                        
          if (containsBundle(importingBundles, bundle)) {
            dynamicImportingPairs.add(new PackageBundlePair(exportedPackage, b));
          }
        }
      }
      
    }
  }
  
  return dynamicImportingPairs;
}

if (persistenceBundle.getState() == Bundle.INSTALLED && providerReference != null) {
  Bundle providerBundle = providerReference.getBundle();
  BundleDescription providerDescription = new BundleDescription(providerBundle.getHeaders());            
  if (needsProviderImports(persistenceBundle, providerDescription)) {

BundleDescription description = new BundleDescription(bundle.getHeaders());

private void scanBundleClassPath(Collection<String> resources, Bundle bundle) {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  List<HeaderEntry> paths = description.getBundleClassPath();
  if (paths.isEmpty()) {
    scanDirectory(resources, bundle, "/");
  } else {
    for (HeaderEntry path : paths) {
      String name = path.getName();
      if (name.equals(".") || name.equals("/")) {
        // scan root
        scanDirectory(resources, bundle, "/");
      } else if (name.endsWith(".jar") || name.endsWith(".zip")) {
        // scan embedded jar/zip
        scanZip(resources, bundle, name);
      } else {
        // assume it's a directory
        scanDirectory(resources, bundle, "/" + name);
      }
    }
  }
}

private boolean scanBundleClassPath(ResourceFinderCallback callback, Bundle bundle) throws Exception {
  BundleDescription desc = new BundleDescription(bundle.getHeaders());
  List<HeaderEntry> paths = desc.getBundleClassPath();
  boolean continueScanning = true;
  if (paths.isEmpty()) {
    continueScanning = scanDirectory(callback, bundle, prefix);
  } else {
    for (HeaderEntry path : paths) {
      String name = path.getName();
      if (name.equals(".") || name.equals("/")) {
        // scan root
        continueScanning = scanDirectory(callback, bundle, prefix);
      } else if (name.endsWith(".jar") || name.endsWith(".zip")) {
        // scan embedded jar/zip
        continueScanning = scanZip(callback, bundle, name);
      } else {
        // assume it's a directory                    
        continueScanning = scanDirectory(callback, bundle, prefix.startsWith("/") ? name + prefix : name + "/" + prefix);
      }
      if (!continueScanning) {
        break;
      }
    }
  }
  return continueScanning;
}

public static LinkedHashSet<Bundle> getWiredBundles(PackageAdmin packageAdmin, Bundle bundle) {
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  // handle static wire via Import-Package
  List<BundleDescription.ImportPackage> imports = description.getExternalImports();
  LinkedHashSet<Bundle> wiredBundles = new LinkedHashSet<Bundle>();
  for (BundleDescription.ImportPackage packageImport : imports) {
    ExportedPackage[] exports = packageAdmin.getExportedPackages(packageImport.getName());
    Bundle wiredBundle = getWiredBundle(bundle, exports);
    if (wiredBundle != null) {
      wiredBundles.add(wiredBundle);
    }
  }
  // handle dynamic wire via DynamicImport-Package
  if (!description.getDynamicImportPackage().isEmpty()) {
    for (Bundle b : bundle.getBundleContext().getBundles()) {
      if (!wiredBundles.contains(b)) {
        ExportedPackage[] exports = packageAdmin.getExportedPackages(b);
        Bundle wiredBundle = getWiredBundle(bundle, exports);
        if (wiredBundle != null) {
          wiredBundles.add(wiredBundle);
        }
      }
    }
  }
  return wiredBundles;
}

private boolean needsProviderImports(Bundle persistenceBundle, BundleDescription providerDescription) {
  BundleDescription description = new BundleDescription(persistenceBundle.getHeaders());
  
  for (HeaderEntry importPackage : description.getDynamicImportPackage()) {
    if ("*".equals(importPackage.getName())) {
      LOG.debug("Persistence bundle {} can load any class.", 
           persistenceBundle.getSymbolicName());
      return false;
    }
  }
  
  for (ImportPackage importPackage : description.getImportPackage()) {
    for (ExportPackage exportPackage : providerDescription.getExportPackage()) {
      if (importPackage.getName().equals(exportPackage.getName())
        && importPackage.getVersionRange().isInRange(exportPackage.getVersion())) {
        LOG.debug("Persistence bundle {} already imports at least one package from JPA provider bundle.",
             persistenceBundle.getSymbolicName());
        return false;
      }
    }
  }
  
  return true;
}

private void scanImportPackages(Collection<String> classes, Bundle host, Bundle fragment) {
  BundleDescription description = new BundleDescription(fragment.getHeaders());
  List<BundleDescription.ImportPackage> imports = description.getExternalImports();
  for (BundleDescription.ImportPackage packageImport : imports) {
    String packageName = packageImport.getName();
    if (discoveryFilter.packageDiscoveryRequired(packageName)) {
      ExportedPackage[] exports = packageAdmin.getExportedPackages(packageName);
      Bundle wiredBundle = isWired(host, exports);
      if (wiredBundle != null) {
        Set<String> allClasses = findAllClasses(wiredBundle, packageName);
        classes.addAll(allClasses);
      }
    }
  }
}

private Set<PackageBundlePair> getImportingPairs(PackageAdmin packageAdmin, Bundle bundle, Set<String> wiredPackages) {
      
  BundleDescription description = new BundleDescription(bundle.getHeaders());
  
  Set<PackageBundlePair> importingPairs = new HashSet<PackageBundlePair>();
  List<BundleDescription.ImportPackage> imports = description.getImportPackage();
  for (BundleDescription.ImportPackage packageImport : imports) {
    //find the packages that we are importing
    ExportedPackage[] exportedPackages = packageAdmin.getExportedPackages(packageImport.getName());
    if (exportedPackages == null) {
      importingPairs.add(new PackageBundlePair(packageImport.getName(), packageImport.getVersionRange().toString(), null));
    } else {
      for (ExportedPackage exportedPackage : exportedPackages) {
        Bundle exportingBundle = exportedPackage.getExportingBundle();
        if (exportingBundle != bundle && containsBundle(exportedPackage.getImportingBundles(), bundle)) {
          importingPairs.add(new PackageBundlePair(packageImport.getName(), packageImport.getVersionRange().toString(), exportedPackage.getExportingBundle()));
          wiredPackages.add(toString(exportedPackage));
        }                    
      }
    }
    
  }
  return importingPairs;
}