Java Requirement类代码示例

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;
}