import org.osgi.resource.Requirement; //导入依赖的package包/类
static List<Requirement> parseRequireBundle(String header) throws IllegalArgumentException {
	if (header == null) {
           return Collections.emptyList();
       }

	Clause[] clauses = Parser.parseHeader(header);
	List<Requirement> requirements = new ArrayList<>(clauses.length);
	for (Clause requireClause : clauses) {
		String bsn = requireClause.getName();
		String versionRangeStr = requireClause.getAttribute(org.osgi.framework.Constants.BUNDLE_VERSION_ATTRIBUTE);

		String filter = toBundleFilter(bsn, versionRangeStr);
		Requirement requirement = new RequirementBuilderImpl(BundleNamespace.BUNDLE_NAMESPACE)
			.addDirective(Namespace.REQUIREMENT_FILTER_DIRECTIVE, filter)
			.build();
		requirements.add(requirement);
	}
	return requirements;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
static List<Requirement> parseRequireCapability(String header) throws IllegalArgumentException {
	if (header == null) {
           return Collections.emptyList();
       }

	Clause[] clauses = Parser.parseHeader(header);
	List<Requirement> reqs = new ArrayList<>(clauses.length);
	for (Clause clause : clauses) {
		String namespace = clause.getName();

		RequirementBuilderImpl reqBuilder = new RequirementBuilderImpl(namespace);
		for (Attribute attrib : clause.getAttributes()) {
               reqBuilder.addAttribute(attrib.getName(), attrib.getValue());
           }
		for (Directive directive : clause.getDirectives()) {
               reqBuilder.addDirective(directive.getName(), directive.getValue());
           }

		reqs.add(reqBuilder.build());
	}

	return reqs;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
public static List<PackageQuery> getRequiredPackages(Bundle bundle) throws BundleException {
	List<PackageQuery> rtn=new ArrayList<PackageQuery>();
	BundleRevision br = bundle.adapt(BundleRevision.class);
	List<Requirement> requirements = br.getRequirements(null);
	Iterator<Requirement> it = requirements.iterator();
	Requirement r;
	Entry<String, String> e;
	String value;
	PackageQuery pd;
	while(it.hasNext()){
		r = it.next();
		Iterator<Entry<String, String>> iit = r.getDirectives().entrySet().iterator();
		inner:while(iit.hasNext()){
			e = iit.next();
			if(!"filter".equals(e.getKey())) continue;
			value=e.getValue();
			pd=toPackageQuery(value);
			if(pd!=null)rtn.add(pd);
		}
	}
	return rtn;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
private void constructInputRequirements() {
	List<Requirement> requires = runModel.getRunRequires();
	if (requires == null || requires.isEmpty()) {
		inputRequirementsResource = null;
	} else {
		ResourceBuilder resBuilder = new ResourceBuilder();
		CapReqBuilder identity = new CapReqBuilder(
				IdentityNamespace.IDENTITY_NAMESPACE).addAttribute(
				IdentityNamespace.IDENTITY_NAMESPACE,
				IDENTITY_INITIAL_RESOURCE);
		resBuilder.addCapability(identity);

		for (Requirement req : requires) {
			resBuilder.addRequirement(req);
		}

		inputRequirementsResource = resBuilder.build();
	}
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
private boolean matches(Requirement requirement, Capability selfCap) {
	boolean match = false;
	try {
		String filterStr = requirement.getDirectives().get(
				Namespace.REQUIREMENT_FILTER_DIRECTIVE);
		org.osgi.framework.Filter filter = filterStr != null ? org.osgi.framework.FrameworkUtil
				.createFilter(filterStr) : null;

		if (filter == null)
			match = true;
		else
			match = filter.match(new MapToDictionaryAdapter(selfCap
					.getAttributes()));
	} catch (InvalidSyntaxException e) {
		log.log(LogService.LOG_ERROR,
				"Invalid filter directive on requirement: " + requirement,
				e);
	}
	return match;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public Set<String> getContractors(Requirement requirement) {
	FilterParser fp = new FilterParser();
	String filter = requirement.getDirectives().get(Namespace.REQUIREMENT_FILTER_DIRECTIVE);
	if (filter != null) {
		Expression expression = fp.parse(filter);
		NitriteVistor nitriteVistor = new NitriteVistor(requirement.getNamespace());
		Filter f = expression.visit(nitriteVistor);

		if (f == null) {
			return Collections.emptySet();
		}

		boolean knownRequirement = false;
		for (String string : supportedNamespaces) {
			if (filter.contains(string)) {
				knownRequirement = true;
				break;
			}
		}

		if (!knownRequirement) {
			return Collections.emptySet();
		}

		NitriteCollection collection = db.getCollection("contracts");
		Cursor cursor = collection.find(f);
		Set<String> result = new HashSet<>();
		for (Document document : cursor) {
			result.add(document.get("contractor", String.class));
		}
		return result;
	}
	return Collections.emptySet();
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
static boolean match(Requirement requirement, Capability capability, LogService log) {
	// Namespace MUST match
	if (!requirement.getNamespace().equals(capability.getNamespace())) {
           return false;
       }

	// If capability effective!=resolve then it matches only requirements with same effective
	String capabilityEffective = capability.getDirectives().get(Namespace.CAPABILITY_EFFECTIVE_DIRECTIVE);
	if (capabilityEffective != null) {
		String requirementEffective = requirement.getDirectives().get(Namespace.REQUIREMENT_EFFECTIVE_DIRECTIVE);
		if (!capabilityEffective.equals(Namespace.EFFECTIVE_RESOLVE) && !capabilityEffective.equals(requirementEffective)) {
               return false;
           }
	}

	String filterStr = requirement.getDirectives().get(Namespace.REQUIREMENT_FILTER_DIRECTIVE);
       if (filterStr == null) {
           return true; // no filter, the requirement always matches
       }

	try {
		Filter filter = FrameworkUtil.createFilter(filterStr);
		return filter.matches(capability.getAttributes());
	} catch (InvalidSyntaxException e) {
		if (log != null) {
			Resource resource = requirement.getResource();
			String id = resource != null ? getIdentity(resource) : "<unknown>";
			log.log(LogService.LOG_ERROR, String.format("Invalid filter syntax in requirement from resource %s: %s", id, filterStr), e);
		}
		return false;
	}
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
void addRequirement(Requirement req) {
	if (req.getResource() != this) {
           req = RequirementImpl.copy(req, this);
       }

	List<Requirement> list = this.requirements.get(req.getNamespace());
	if (list == null) {
		list = new LinkedList<>();
		this.requirements.put(req.getNamespace(), list);
	}
	list.add(req);
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public List<Requirement> getRequirements(String namespace) {
	List<Requirement> result;
	if (namespace == null) {
		result = new LinkedList<>();
		for (List<Requirement> list : this.requirements.values()) {
               result.addAll(list);
           }
	} else {
		result = this.requirements.get(namespace);
	}
	return result != null ? result : Collections.emptyList();
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Test
public void testParseRequireBundle() {
	List<Requirement> actual = RequirementParser.parseRequireBundle("foo;bundle-version=1.0.0, bar;bundle-version=\"[1.0,1.1)\", baz;bundle-version=\"[2.0,3.0)\", fnarg");
	
	assertEquals(4, actual.size());
	assertEquals("(&(osgi.wiring.bundle=foo)(bundle-version>=1.0.0))", actual.get(0).getDirectives().get("filter"));
	assertEquals("(&(osgi.wiring.bundle=bar)(bundle-version>=1.0.0)(!(bundle-version>=1.1.0)))", actual.get(1).getDirectives().get("filter"));
	assertEquals("(&(osgi.wiring.bundle=baz)(bundle-version>=2.0.0)(!(bundle-version>=3.0.0)))", actual.get(2).getDirectives().get("filter"));
	assertEquals("(osgi.wiring.bundle=fnarg)", actual.get(3).getDirectives().get("filter"));
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Test
public void testParseRequireCapability() {
	List<Requirement> actual = RequirementParser.parseRequireCapability("osgi.extender; filter:=\"(&(osgi.extender=osgi.ds)(version>=1.0))\"; effective:=active, osgi.service; filter:=\"(objectClass=org.example.Foo)\"");
	
	assertEquals(2, actual.size());
	assertEquals("(&(osgi.extender=osgi.ds)(version>=1.0))", actual.get(0).getDirectives().get("filter"));
	assertEquals("active", actual.get(0).getDirectives().get("effective"));
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public RepositoryResourceMatchingData createMatchingData() {
    ExtendedMatchingData matchingData = new ExtendedMatchingData();
    matchingData.setType(getType());
    matchingData.setName(getName());
    matchingData.setProviderName(getProviderName());

    if ((getType().equals(ResourceType.INSTALL))) {
        matchingData.setVersion(getProductVersion());
    } else {
        // Regen the appliesToFilterInfo as the level of code that generated each resource may
        // be different and give us different results so regen it now.
        try {
            List<AppliesToFilterInfo> atfi = generateAppliesToFilterInfoList(false);
            matchingData.setAtfi(atfi);
        } catch (RepositoryResourceCreationException e) {
            // This should only be thrown if validate editions is set to true, for us its set to false
        }
    }

    for (Requirement requirement : getGenericRequirements()) {
        if (requirement.getNamespace().equals("osgi.native")) {
            matchingData.setPlatformInfo(requirement.getDirectives().get("filter"));
        }
    }

    return matchingData;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public Collection<Requirement> getGenericRequirements() {
    //converts a string format of the generic requirements into a collection of Requirement objects
    String requirementStr = _asset.getWlpInformation().getGenericRequirements();
    Collection<Requirement> requirements = new HashSet<Requirement>();
    List<GenericMetadata> genMetList = ManifestHeaderProcessor.parseRequirementString(requirementStr);
    for (GenericMetadata genMet : genMetList) {
        Requirement req = new GenericRequirement(genMet);
        requirements.add(req);
    }
    return requirements;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
public Map<Requirement,Collection<Capability>> findProviders(Collection< ? extends Requirement> requirements) {
    Map<Requirement,Collection<Capability>> result = new HashMap<Requirement,Collection<Capability>>();
    for (Requirement requirement : requirements) {
        List<Capability> matches = new LinkedList<Capability>();
        result.put(requirement, matches);

        capIndex.appendMatchingCapabilities(requirement, matches);
    }
    return result;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public boolean isEffective(Requirement requirement) {
	init();
	String effective = requirement.getDirectives().get(
			Namespace.REQUIREMENT_EFFECTIVE_DIRECTIVE);
	if (effective == null || Namespace.EFFECTIVE_RESOLVE.equals(effective))
		return true;

	if (effectiveSet != null && effectiveSet.contains(effective))
		return true;

	return false;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
public static RequirementImpl copy(Requirement req, Resource resource) {
	return new RequirementImpl(req.getNamespace(), req.getDirectives(), req.getAttributes(), resource);
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public List<Capability> findProviders(Requirement requirement) {
	List<Capability> resultCaps = new LinkedList<>();

	// Find from installed bundles
	Bundle[] bundles = this.bundleContext.getBundles();
	for (Bundle bundle : bundles) {
           if (bundle.getState() == Bundle.UNINSTALLED) {
               continue; // Skip UNINSTALLED bundles
           }

		BundleRevision revision = bundle.adapt(BundleRevision.class);
		List<Capability> bundleCaps = revision.getCapabilities(requirement.getNamespace());
		if (bundleCaps != null) {
               for (Capability bundleCap : bundleCaps) {
               	if (match(requirement, bundleCap, this.log)) {
                       resultCaps.add(bundleCap);
                   }
               }
           }
	}

	// Find from repositories
	for (Entry<URI, Repository> repoEntry : this.repositories.entrySet()) {
		Repository repository = repoEntry.getValue();
		Map<Requirement, Collection<Capability>> providers = repository.findProviders(Collections.singleton(requirement));
		if (providers != null) {
			Collection<Capability> repoCaps = providers.get(requirement);
			if (repoCaps != null) {
				resultCaps.addAll(repoCaps);

				for (Capability repoCap : repoCaps) {
					// Get the list of physical URIs for this resource.
					Resource resource = repoCap.getResource();
					// Keep track of which repositories own which resources.
					this.resourceRepositoryMap.putIfAbsent(resource, repository);

					// Resolve the Resource's URI relative to the Repository Index URI and save for later.
					URI repoIndexUri = repoEntry.getKey();
					URI resolvedUri = resolveResourceLocation(resource, repoIndexUri);
					if (resolvedUri != null) {
						// Cache the resolved URI into the resource URI map, which will be used after resolve.
						this.resourceLocationMap.put(resource, resolvedUri.toString());
					}
				}
			}
		}
	}
	return resultCaps;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
@Override
public boolean isEffective(Requirement requirement) {
	return true;
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
public Collection<Requirement> getRequirements() {
    return Collections.unmodifiableCollection(this.requirements);
}
 

import org.osgi.resource.Requirement; //导入依赖的package包/类
private ResolveRequest analyseFile(File file) throws IOException {
    log(LogService.LOG_INFO, null, "Resolving bundle archive: %s", file.getAbsolutePath());

    String fileUriStr = file.toURI().toString();
    String indexUriStr;
    String name;
    String symbolicName;
    String version = "";

    List<Requirement> requirements = new LinkedList<>();
    try (JarFile jar = new JarFile(file)) {
        Attributes manifestAttribs = jar.getManifest().getMainAttributes();

        symbolicName = manifestAttribs.getValue(Constants.DEPLOYMENT_SYMBOLIC_NAME);
        if (symbolicName == null) {
            symbolicName = file.getName();
        }

        name = manifestAttribs.getValue(Constants.DEPLOYMENT_NAME);
        if (name == null) {
            name = symbolicName;
        }

        version = manifestAttribs.getValue(Constants.DEPLOYMENT_VERSION);
        if (version == null) {
            version = UNKNOWN_DEPLOYMENT_VERSION;
        }
        requirements.addAll(RequirementParser.parseRequireBundle(manifestAttribs.getValue(org.osgi.framework.Constants.REQUIRE_BUNDLE)));
        requirements.addAll(RequirementParser.parseRequireCapability(manifestAttribs.getValue(org.osgi.framework.Constants.REQUIRE_CAPABILITY)));
        if (requirements.isEmpty()) {
            throw new IllegalArgumentException(String.format("Missing %s or %s header in manifest in %s", org.osgi.framework.Constants.REQUIRE_BUNDLE, org.osgi.framework.Constants.REQUIRE_CAPABILITY, file.getAbsolutePath()));
        }

        JarEntry indexEntry = findEntry(jar, Constants.INDEX_FILE, Constants.DEFAULT_INDEX_FILE);
        if (indexEntry == null) {
            throw new IllegalArgumentException("Missing index entry in " + file.getAbsolutePath());
        }
        indexUriStr = "jar:" + fileUriStr + "!/" + indexEntry.getName();
    }

    try {
        ResolveRequest request = new ResolveRequest(name, symbolicName, version,
                Collections.singletonList(new URI(indexUriStr)), requirements);

        return request;
    } catch (URISyntaxException e) {
        throw new IOException("Unable to convert index URI " + indexUriStr, e);
    }
}