packages.java

OSGI这是一个中间件,与UPNP齐名,是用于移植到嵌入式平台之上

    tempResolved = null;
    return res;
  }


  /**
   * Get selected provider of a package.
   *
   * @param pkg Exported package.
   * @return PkgEntry that exports the package, null if no provider.
   */
  synchronized PkgEntry getProvider(String pkg) {
    Pkg p = (Pkg)packages.get(pkg);
    if (p != null) {
      return p.provider;
    } else {
      return null;
    }
  }
    
    
  /**
   * Check if PkgEntry is provider of a package.
   *
   * @param pe Exported package.
   * @return True if pkg exports the package.
   */
  synchronized boolean isProvider(PkgEntry pe) {
    return pe.pkg != null && pe.pkg.provider == pe;
  }
    
    
  /**
   * Check if a package is in zombie state.
   *
   * @param pe Package to check.
   * @return True if pkg is zombie exported.
   */
  synchronized boolean isZombiePackage(PkgEntry pe) {
    return pe.pkg != null && pe.pkg.zombie;
  }
    
    
  /**
   * Get all packages exported by the system.
   *
   * @return Export-package string for system bundle.
   */
  synchronized String systemPackages() {
    StringBuffer res = new StringBuffer();
    for (Iterator i = packages.values().iterator(); i.hasNext();) {
      Pkg p = (Pkg)i.next();
      PkgEntry pe = p.provider;
      if (pe != null && framework.systemBundle == pe.bundle) {
	if (res.length() > 0) {
	  res.append(", ");
	}
	res.append(pe.pkgString());
      }
    }
    return res.toString();
  }


  /**
   * Get specification version of an exported package.
   *
   * @param pkg Exported package.
   * @param bundle Exporting bundle.
   * @return Version of package or null if unspecified.
   */
  synchronized String getPackageVersion(String pkg) {
    Pkg p = (Pkg)packages.get(pkg);
    PkgEntry pe = p.provider;
    return pe != null && pe.version.isSpecified() ? pe.version.toString() : null;
  }


  /**
   * Get packages provide by bundle. If bundle is null, get all.
   *
   * @param b Bundle exporting packages.
   * @return List of packages exported by bundle.
   */
  synchronized Collection getPackagesProvidedBy(Bundle b) {
    ArrayList res = new ArrayList();
    for (Iterator i = packages.values().iterator(); i.hasNext();) {
      Pkg p = (Pkg) i.next();
      if (p.provider != null && (b == null || b == p.provider.bundle)) {
	res.add(p.provider);
      }
    }
    return res;
  }


  /**
   * Get active importers of a package.
   *
   * @param pkg Package.
   * @return List of bundles importering.
   */
  synchronized Collection getPackageImporters(String pkg) {
    Pkg p = (Pkg)packages.get(pkg);
    Set res = new HashSet();
    if (p != null && p.provider != null) {
      List i = p.importers;
      for (int x =  0; x < i.size(); x++ ) {
	PkgEntry pe = (PkgEntry)i.get(x);
	if (pe.bundle.state != Bundle.INSTALLED) {
	  res.add(pe.bundle);
	}
      }
    }
    return res;
  }


  /**
   * Get bundles affected by zombie packages.
   * Compute a graph of bundles starting with the specified bundles.
   * If no bundles are specified, compute a graph of bundles starting
   * with all exporting a zombie package.
   * Any bundle that imports a package that is currently exported
   * by a bundle in the graph is added to the graph. The graph is fully
   * constructed when there is no bundle outside the graph that imports a
   * package from a bundle in the graph. The graph may contain
   * <tt>UNINSTALLED</tt> bundles that are currently still
   * exporting packages.
   *
   * @param bundles Initial bundle set.
   * @return List of bundles affected.
   */
  synchronized Collection getZombieAffected(Bundle [] bundles) {
//XXX - begin L-3 modification
    // set of affected bundles will be in start-level/bundle-id order  
    TreeSet affected = new TreeSet(new Comparator() {
      public int compare(Object o1, Object o2) {
	BundleImpl b1 = (BundleImpl)o1; 
	BundleImpl b2 = (BundleImpl)o2;
	int dif  = b1.getStartLevel() - b2.getStartLevel();
	if (dif == 0) {
	    dif  = (int)(b1.getBundleId() - b2.getBundleId());
	}
	return dif;
      }
      public boolean equals(Object o) {
	return ((o != null) && getClass().equals(o.getClass()));
      }
    });
//XXX - end L-3 modification
    if (bundles == null) {
      if (Debug.packages) {
	Debug.println("getZombieAffected: check - null");
      }
      for (Iterator i = packages.values().iterator(); i.hasNext();) {
	Pkg p = (Pkg)i.next();
	PkgEntry pe = p.provider;
	if (pe != null && p.zombie) {
	  if (Debug.packages) {
	    Debug.println("getZombieAffected: found zombie - " + pe.bundle);
	  }
	  affected.add(pe.bundle);
	}
      }
    } else {
      for (int i = 0; i < bundles.length; i++) {
	if (bundles[i] != null) {
	  if (Debug.packages) {
	    Debug.println("getZombieAffected: check - " + bundles[i]);
	  }
	  affected.add(bundles[i]);
	}
      }
    }
    ArrayList moreBundles = new ArrayList(affected);
    for (int i = 0; i < moreBundles.size(); i++) {
      BundleImpl b = (BundleImpl)moreBundles.get(i);
      for (Iterator j = b.getExports(); j.hasNext(); ) {
	PkgEntry pe = (PkgEntry)j.next();
	if (pe.pkg != null && pe.pkg.provider == pe) {
	  for (Iterator k = getPackageImporters(pe.name).iterator(); k.hasNext(); ) {
	    Bundle ib = (Bundle)k.next();
	    if (!affected.contains(ib)) {
	      moreBundles.add(ib);
	      if (Debug.packages) {
		Debug.println("getZombieAffected: added - " + ib);
	      }
	      affected.add(ib);
	    }
	  }
	}
      }
    }
    return affected;
  }

  //
  // Private methods.
  //

  /**
   * Check if a bundle has all its package dependencies resolved.
   *
   * @param pkgs List of packages to be resolved.
   * @return List of packages not resolvable.
   */
  private List resolvePackages(Iterator pkgs) {
    ArrayList res = new ArrayList();
    while (pkgs.hasNext()) {
      PkgEntry pe = (PkgEntry)pkgs.next();
      if (Debug.packages) {
	Debug.println("resolvePackages: check - " + pe.pkgString());
      }
      PkgEntry provider = pe.pkg.provider;
      if (provider == null) {
	provider = (PkgEntry)tempProvider.get(pe.name);
	if (provider == null) {
	  provider = pickProvider(pe.pkg);
	} else if (Debug.packages) {
	  Debug.println("resolvePackages: " + pe.name + " - has temporay provider - "
			+ provider);
	}
      } else if (Debug.packages) {
	Debug.println("resolvePackages: " + pe.name + " - has provider - " + provider);
      }
      if (provider == null) {
	if (Debug.packages) {
	  Debug.println("resolvePackages: " + pe.name + " - has no provider");
	}
	res.add(pe);
      } else if (provider.compareVersion(pe) < 0) {
	if (Debug.packages) {
	  Debug.println("resolvePackages: " + pe.name + " - provider has wrong version - " + provider + ", need " + pe.version + ", has " + provider.version);
	}
	res.add(pe);
      }
    }
    return res;
  }


  /**
   * Find a provider for specified package.
   *
   * @param pkg Package to find provider for.
   * @return Package entry that can provide.
   */
  private PkgEntry pickProvider(Pkg p) {
    if (Debug.packages) {
      Debug.println("pickProvider: for - " + p.pkg);
    }
    PkgEntry provider = null;
    for (Iterator i = p.exporters.iterator(); i.hasNext(); ) {
      PkgEntry pe = (PkgEntry)i.next();
      if ((pe.bundle.state & RESOLVED_FLAGS) != 0) {
	provider = pe;
	break;
      }
      if (pe.bundle.state == Bundle.INSTALLED) {
	if (tempResolved.contains(pe.bundle)) {
	  provider = pe;
	  break;
	}
	int oldTempStartSize = tempResolved.size();
	HashMap oldTempProvider = (HashMap)tempProvider.clone();
	tempResolved.add(pe.bundle);
	List r = resolvePackages(pe.bundle.getImports());
	if (r.size() == 0) {
	  provider = pe;
	  break;
	} else {
	  tempProvider = oldTempProvider;
	  for (int x = tempResolved.size() - 1; x >= oldTempStartSize; x--) {
	    tempResolved.remove(x);
	  }
	}
      }
    }
    if (provider != null) {
      if (Debug.packages) {
	Debug.println("pickProvider: " + p.pkg + " - got provider - " + provider);
      }
      tempProvider.put(p.pkg, provider);
    }
    return provider;
  }

}