Require-Capability ::= requirement ( ‘,’ requirement )*
Description: Parameters requirements = new Parameters(annotationHeaders.getHeader(REQUIRE_CAPABILITY)); Parameters capabilities = new Parameters(annotationHeaders.getHeader(PROVIDE_CAPABILITY));
Date: 2019-10-12T20:06:21-04:00

- # Require-Capability ::= requirement ( ',' requirement )*

      			Parameters requirements = new Parameters(annotationHeaders.getHeader(REQUIRE_CAPABILITY));
      		Parameters capabilities = new Parameters(annotationHeaders.getHeader(PROVIDE_CAPABILITY));

      		//
      		// Do any contracts contracts
      		//
      		contracts.addToRequirements(requirements);

      		//
      		// We want to add the minimum EE as a requirement
      		// based on the class version
      		//

      		if (!isTrue(getProperty(NOEE)) //
      				&& !ees.isEmpty() // no use otherwise
      				&& since(About._2_3) // we want people to not have to
      										// automatically add it
      				&& !requirements.containsKey(ExecutionEnvironmentNamespace.EXECUTION_ENVIRONMENT_NAMESPACE) // and
      																											// it
      																											// should
      																											// not
      																											// be
      																											// there
      																											// already
      		) {

      			JAVA highest = ees.last();
      			Attrs attrs = new Attrs();

      			String filter = doEEProfiles(highest);

      			attrs.put(Constants.FILTER_DIRECTIVE, filter);

      			//
      			// Java 1.8 introduced profiles.
      			// If -eeprofile= auto | (<profile>="...")+ is set then
      			// we add a

      			requirements.add(ExecutionEnvironmentNamespace.EXECUTION_ENVIRONMENT_NAMESPACE, attrs);
      		}

      		if (!requirements.isEmpty())
      			main.putValue(REQUIRE_CAPABILITY, requirements.toString());

      	/*
       * Require-Capability header
       */
      private void doRequireCapability(RequireCapability annotation) {
      	StringBuilder sb = new StringBuilder(annotation.ns());
      	if (annotation.filter() != null)
      		sb.append(";filter:='").append(annotation.filter()).append("'");
      	if (annotation.effective() != null)
      		sb.append(";effective:='").append(annotation.effective()).append("'");
      	if (annotation.resolution() != null)
      		sb.append(";resolution:='").append(annotation.resolution()).append("'");

      	if (annotation.value() != null)
      		sb.append(";").append(annotation.value());

      	add(Constants.REQUIRE_CAPABILITY, sb.toString());
      }

      package aQute.bnd.annotation.headers;

      	import java.lang.annotation.*;

      	/**
      	 * The Bundle’s Require-Capability header
      	 *
      	 * {@link About}
      	 */
      	@Retention(RetentionPolicy.CLASS)
      	@Target({
      			ElementType.ANNOTATION_TYPE, ElementType.TYPE
      	})
      	public @interface RequireCapability {
      		String value() default "";

      		/**
      		 * The capability namespace. For example: {@code osgi.contract}.
      		 */
      		String ns();

      		/**
      		 * Specifies the time a Requirement is considered, either 'resolve'
      		 * (default) or another name. The OSGi framework resolver only considers
      		 * Requirements without an effective directive or effective:=resolve. Other
      		 * Requirements can be considered by an external agent. Additional names for
      		 * the effective directive should be registered with the OSGi Alliance. See
      		 * <a href="https://www.osgi.org/developer/specifications/reference/">OSGi Reference
      		 * Page</a>
      		 */
      		String effective() default "resolve";

      		/**
      		 * A filter expression that is asserted on the Capabilities belonging to the
      		 * given namespace. The matching of the filter against the Capability is
      		 * done on one Capability at a time. A filter like {@code (&(a=1)(b=2))}
      		 * matches only a Capability that specifies both attributes at the required
      		 * value, not two capabilties that each specify one of the attributes
      		 * correctly. A filter is optional, if no filter directive is specified the
      		 * Requirement always matches.
      		 */
      		String filter();

      		/**
      		 * A mandatory Requirement forbids the bundle to resolve when the
      		 * Requirement is not satisfied; an optional Requirement allows a bundle to
      		 * resolve even if the Requirement is not satisfied. No wirings are created
      		 * when this Requirement cannot be resolved, this can result in Class Not
      		 * Found Exceptions when the bundle attempts to use a package that was not
      		 * resolved because it was optional.
      		 */
      		Resolution resolution() default Resolution.mandatory;

      	}

      		private void verifyRequirements() {
      	Parameters map = parseHeader(manifest.getMainAttributes().getValue(Constants.REQUIRE_CAPABILITY));
      	for (String key : map.keySet()) {
      		Attrs attrs = map.get(key);
      		verify(attrs, "filter:", FILTERPATTERN, false, "Requirement %s filter not correct", key);

      		String filter = attrs.get("filter:");
      		if (filter != null) {
      			String verify = new Filter(filter).verify();
      			if (verify != null)
      				error("Invalid filter syntax in requirement %s=%s. Reason %s", key, attrs, verify);
      		}
      		verify(attrs, "cardinality:", CARDINALITY_PATTERN, false, "Requirement %s cardinality not correct", key);
      		verify(attrs, "resolution:", RESOLUTION_PATTERN, false, "Requirement %s resolution not correct", key);

      		if (key.equals("osgi.extender")) {
      			// No requirements on extender
      		} else if (key.equals("osgi.serviceloader")) {
      			verify(attrs, "register:", PACKAGEPATTERN, false,
      					"Service Loader extender register: directive not a fully qualified Java name");
      		} else if (key.equals("osgi.contract")) {

      		} else if (key.equals("osgi.service")) {

      		} else if (key.equals("osgi.ee")) {

      		} else if (key.startsWith("osgi.wiring.") || key.startsWith("osgi.identity")) {
      			error("osgi.wiring.* namespaces must not be specified with generic requirements/capabilities");
      		}

      		verifyAttrs(attrs);

      		if (attrs.containsKey("mandatory:"))
      			error("mandatory: directive is intended for Capabilities, not Requirement %s", key);

      		if (attrs.containsKey("uses:"))
      			error("uses: directive is intended for Capabilities, not Requirement %s", key);
      	}
      }