org.osgi.framework.wiring.BundleRequirement Java Examples

@Override
String getReqName(final BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);
  final String filter = requirement.getDirectives().get("filter");
  final String eeName = getFilterValue(filter, ExecutionEnvironmentNamespace.EXECUTION_ENVIRONMENT_NAMESPACE);

  if (eeName != null) {
    sb.append(eeName);
    appendVersion(sb, requirement);
  } else {
    // Filter too complex to extract info from...
    sb.append(filter);
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

public List<BundleRequirement> getDeclaredRequirements(String namespace)
{
    List<BundleRequirement> result = m_declaredReqs;
    if (namespace != null)
    {
        result = new ArrayList<BundleRequirement>();
        for (BundleRequirement req : m_declaredReqs)
        {
            if (req.getNamespace().equals(namespace))
            {
                result.add(req);
            }
        }
    }
    return result;
}
 

public List<BundleRequirement> getDeclaredRequirements(String namespace)
{
    List<BundleRequirement> result = m_declaredReqs;
    if (namespace != null)
    {
        result = new ArrayList<BundleRequirement>();
        for (BundleRequirement req : m_declaredReqs)
        {
            if (req.getNamespace().equals(namespace))
            {
                result.add(req);
            }
        }
    }
    return result;
}
 

void filterMatches(BundleRequirement requirement , Collection<? extends BundleCapability> candidates) throws BundleException {
  if (hasHooks()) {
    @SuppressWarnings("unchecked")
    Collection<BundleCapability> c = new RemoveOnlyCollection<BundleCapability>((Collection<BundleCapability>) candidates);
    blockResolveForHooks();
    try {
      for (TrackedResolverHookFactory rhf : active) {
        final ResolverHook rh = checkActiveRemoved(rhf);
        try {
          rh.filterMatches(requirement, c);
        } catch (RuntimeException re) {
          throw new BundleException("Resolver hook throw an exception, bid="
                                    + rhf.bundle.getBundleId(),
                                    BundleException.REJECTED_BY_HOOK, re);
        }
      }
    } finally {
      unblockResolveForHooks();
    }
  }
}
 

BundleRevisionDTO getDTO() {
  BundleRevisionDTO res = new BundleRevisionDTO();
  res.symbolicName = gen.symbolicName;
  res.type = getTypes();
  res.version = gen.version.toString();
  res.bundle = gen.bundle.id;
  res.id = dtoId;
  res.capabilities = new ArrayList<CapabilityDTO>();
  for (BundleCapability bc :  getDeclaredCapabilities(null)) {
    res.capabilities.add(BundleCapabilityImpl.getDTO(bc, this));
  }
  res.requirements = new ArrayList<RequirementDTO>();
  for (BundleRequirement br :  getDeclaredRequirements(null)) {
    res.requirements.add(BundleRequirementImpl.getDTO(br, this));
  }
  return res;
}
 

@Override
String getReqName(final BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);
  final String filter = requirement.getDirectives().get("filter");
  final String pkgName =
    getFilterValue(filter, BundleRevision.PACKAGE_NAMESPACE);
  if (pkgName != null) {
    sb.append(pkgName);
    appendVersionAndResolutionDirective(sb, requirement);
  } else {
    sb.append(filter);
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

private void appendVersionAndResolutionDirective(final StringBuffer sb,
                                                 final BundleRequirement requirement)
{
  final String filter =
    requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);

  try {
    final VersionRange vr =
      new VersionRange(filter, Constants.VERSION_ATTRIBUTE, true);
    sb.append(" ");
    sb.append(vr.toHtmlString());
  } catch (final IllegalArgumentException iae) {
    System.err.println(iae.getMessage());
  }

  final String resolution =
    requirement.getDirectives().get(Constants.RESOLUTION_DIRECTIVE);
  if (resolution != null && resolution.length() > 0) {
    if (resolution.equals(Constants.RESOLUTION_MANDATORY)) {
      // Default, don't print
    } else {
      sb.append(" ");
      sb.append(resolution);
    }
  }
}
 

@Override
String getReqName(final BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);
  final String filter = requirement.getDirectives().get("filter");
  final String bundleName =
    getFilterValue(filter, BundleRevision.BUNDLE_NAMESPACE);
  if (bundleName != null) {
    sb.append(bundleName);
    appendVersion(sb, requirement);
  } else {
    // Filter too complex to extract info from...
    sb.append(filter);
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

@Override
String getReqName(final BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);
  final String filter = requirement.getDirectives().get("filter");
  final String idName = getFilterValue(filter, IdentityNamespace.IDENTITY_NAMESPACE);
  if (idName != null) {
    sb.append(idName);
    appendVersionAndType(sb, requirement);
  } else {
    // Filter too complex to extract info from...
    sb.append(filter);
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

private void appendVersionAndType(final StringBuffer sb,
                                  final BundleRequirement requirement)
{
  final String filter =
    requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);

  try {
    final VersionRange vr =
      new VersionRange(filter, Constants.VERSION_ATTRIBUTE, false);
    sb.append(" ");
    sb.append(vr.toHtmlString());
  } catch (final IllegalArgumentException iae) {
  }

  final String type = getFilterValue(filter, "type");
  if (type != null) {
    sb.append(" ");
    sb.append(type);
  }
}
 

@Override
String getReqName(final BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);
  final String filter = requirement.getDirectives().get("filter");
  final String hostName = getFilterValue(filter, BundleRevision.HOST_NAMESPACE);
  if (hostName != null) {
    sb.append(hostName);
    appendVersion(sb, requirement);
  } else {
    // Filter too complex to extract info from...
    sb.append(filter);
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

/**
 * Present a generic requirement by showing its filter.
 *
 * @param requirement The requirement to present.
 * @return string presentation of the requirement.
 */
String getReqName(BundleRequirement requirement)
{
  final StringBuffer sb = new StringBuffer(50);

  final String filter = requirement.getDirectives().get("filter");
  if (filter != null) {
    sb.append(filter);
  } else {
    sb.append(" &emdash; ");
  }

  final BundleWiring reqWiring = requirement.getRevision().getWiring();
  appendPendingRemovalOnRefresh(sb, reqWiring);

  return sb.toString();
}
 

private MultiMap<String, BundleRequirement> parseRequirements(
		final String str) throws BundleException {
	final MultiMap<String, BundleRequirement> result = new MultiMap<String, BundleRequirement>();

	if (str == null) {
		return result;
	}

	final String[] reqStrs = Utils.splitString(str, ',');
	for (int i = 0; i < reqStrs.length; i++) {
		final BundleRequirementImpl req = new BundleRequirementImpl(
				this, reqStrs[i]);
		final String namespace = req.getNamespace();
		result.insert(namespace, req);
	}
	return result;
}
 

String getFragmentHost() {
	final List<BundleRequirement> hostReqs = requirements
			.get(HostNamespace.HOST_NAMESPACE);
	if (hostReqs == null) {
		return null;
	}

	return hostReqs.get(0).getDirectives()
			.get(HostNamespace.HOST_NAMESPACE);
}
 

boolean filterMatches(BundleRequirement requirement , BundleCapability candidate) throws BundleException {
  if (hasHooks()) {
    Collection<BundleCapability> c = new ShrinkableSingletonCollection<BundleCapability>(candidate);
    filterMatches(requirement, c);
    return !c.isEmpty();
  }
  return true;
}
 

/**
 * Get the list bundle requirements derived from the Require-Bundle header.
 * The bundle requirement objects for required bundles in the list has the
 * same order as the bundles in the Require-Bundle header.
 *
 * @return all defined require bundle requirements for this bundle revision.
 */
List<BundleRequirement> getDeclaredBundleRequirements() {
  final List<BundleRequirement> res = new ArrayList<BundleRequirement>();

  if (require!=null) {
    final TreeSet<RequireBundle> rbCreationOrder
      = new TreeSet<RequireBundle>(require);
    res.addAll(rbCreationOrder);
  }
  return res;
}
 

BundleWireImpl(BundleCapability capability, BundleGeneration provider,
               BundleRequirement requirement, BundleGeneration requirer) {
  this.capability = capability;
  this.providerGen = provider;
  this.requirement = requirement;
  this.requirerGen = requirer;
}
 

static RequirementDTO getDTO(BundleRequirement br, BundleRevisionImpl bri) {
  RequirementDTO res = new RequirementDTO();
  res.id = ((DTOId)br).dtoId;
  res.namespace = br.getNamespace();
  res.directives = new HashMap<String, String>(br.getDirectives());
  res.attributes = Util.safeDTOMap(br.getAttributes());
  res.resource = bri.dtoId;
  return res;
}
 

@Override
public String toString() {
  final StringBuffer sb = new StringBuffer(40);

  sb.append("[")
  .append(BundleRequirement.class.getName())
  .append(": ")
  .append(namespace)
  .append(" directives: ")
  .append(directives.toString())
  .append("]");

  return sb.toString();
}
 

List<RequirementRefDTO> getRequirementRefDTOs() {
  List<RequirementRefDTO> res = new ArrayList<RequirementRefDTO>();
  for (BundleRequirement br :  getDeclaredRequirements(null)) {
    res.add(BundleRequirementImpl.getRefDTO(br, this));
  }
  return res;
}
 

public List<BundleRequirement> getRequirements(final String namespace) {
	if (!isInUse()) {
		return null;
	}

	return namespace == null ? requirements.getAllValues()
			: requirements.lookup(namespace);
}
 

private void appendVersion(final StringBuffer sb,
                           final BundleRequirement requirement)
{
  final String filter =
    requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);

  try {
    final VersionRange vr =
      new VersionRange(filter, Constants.BUNDLE_VERSION_ATTRIBUTE, true);
    sb.append(" ");
    sb.append(vr.toHtmlString());
  } catch (final IllegalArgumentException iae) {
    System.err.println(iae.getMessage());
  }
}
 

void refresh() {
	// iterate over old and current revisions
	for (final BundleRevision brev : revisions) {
		final Revision rev = (Revision) brev;

		if (rev.wiring != null) {
			rev.wiring.cleanup();
			rev.wiring = null;
		}
	}

	revisions.clear();

	if (currentRevision != null) {
		revisions.add(currentRevision);

		// detach fragments (if any) and reset classloader
		currentRevision.refresh();

		// remove from framework wirings
		framework.wirings.remove(currentRevision);

		// clear and restore dynamic imports
		currentRevision.dynamicImports.clear();
		for (final BundleRequirement req : currentRevision.requirements
				.lookup(PackageNamespace.PACKAGE_NAMESPACE)) {
			if (PackageNamespace.RESOLUTION_DYNAMIC
					.equals(req.getDirectives().get(
							Namespace.REQUIREMENT_RESOLUTION_DIRECTIVE))) {
				currentRevision.dynamicImports.add(req);
			}

		}
	}
}
 

private void appendVersion(final StringBuffer sb,
                           final BundleRequirement requirement)
{
  final String filter =
    requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);

  try {
    final VersionRange vr =
      new VersionRange(filter, Constants.VERSION_ATTRIBUTE, true);
    sb.append(" ");
    sb.append(vr.toHtmlString());
  } catch (final IllegalArgumentException iae) {
    System.err.println(iae.getMessage());
  }
}
 

private void appendVersion(final StringBuffer sb,
                           final BundleRequirement requirement)
{
  final String filter =
    requirement.getDirectives().get(Constants.FILTER_DIRECTIVE);

  try {
    final VersionRange vr =
      new VersionRange(filter, Constants.BUNDLE_VERSION_ATTRIBUTE, true);
    sb.append(" ");
    sb.append(vr.toHtmlString());
  } catch (final IllegalArgumentException iae) {
    System.err.println(iae.getMessage());
  }
}
 

List<BundleCapability> resolveDynamic(final BundleRevision trigger,
		final String pkg, final String dynImportPackage,
		final BundleRequirement dynImport, final boolean multiple) {
	Collection<Capability> candidates = null;

	try {
		if (resolver.hooks == null) {
			resolver.hooks = getResolverHooks(Arrays.asList(trigger));
		}

		final String filterStr = dynImport.getDirectives()
				.get(Namespace.REQUIREMENT_FILTER_DIRECTIVE);

		if (multiple) {
			// we have a wildcard, this means scanning
			candidates = capabilityRegistry
					.getAll(PackageNamespace.PACKAGE_NAMESPACE);
		} else {
			// we don't have a wildcard, use the index
			if (filterStr == null) {
				candidates = capabilityRegistry.getByValue(
						PackageNamespace.PACKAGE_NAMESPACE,
						dynImportPackage);
			} else {
				try {
					candidates = RFC1960Filter.filterWithIndex(dynImport,
							filterStr, capabilityRegistry);
				} catch (final InvalidSyntaxException e) {
					e.printStackTrace();
				}
			}
		}

		if (candidates == null || candidates.isEmpty()) {
			endResolverHooks(resolver.hooks);
			return null;
		}

		filterCandidates(resolver.hooks.keySet(), dynImport, candidates);

		final ArrayList<BundleCapability> matches = new ArrayList<BundleCapability>();

		for (final Capability cap : candidates) {
			final String candidatePackage = (String) cap.getAttributes()
					.get(PackageNamespace.PACKAGE_NAMESPACE);

			assert candidatePackage != null;

			if (multiple && RFC1960Filter.stringCompare(pkg.toCharArray(),
					0, candidatePackage.toCharArray(), 0) != 0) {
				continue;
			}

			if (cap instanceof BundleCapability && Concierge.matches0(
					PackageNamespace.PACKAGE_NAMESPACE, dynImport, cap,
					filterStr)) {
				// we have a match
				// FIXME: cleanup...
				if (((BundleCapability) cap).getRevision().getBundle()
						.getState() == Bundle.INSTALLED) {
					// need to resolve first
					if (!resolve(
							Collections.singletonList(
									((BundleCapability) cap).getRevision()),
							false)) {
						continue;
					}
				}

				matches.add((BundleCapability) cap);
			}

		}

		endResolverHooks(resolver.hooks);

		Collections.sort(matches, EXPORT_ORDER);
		return matches;
	} catch (final Throwable t) {
		// TODO: handle
		return null;
	} finally {
		resolver.hooks = null;
	}

}
 

@Override
public List<BundleRequirement> getDeclaredRequirements(String p1) {
    throw new UnsupportedOperationException();
}
 

@Override
public List<BundleRequirement> getRequirements(String p1) {
    throw new UnsupportedOperationException();
}
 

/**
 * @see org.osgi.framework.wiring.BundleRevision#getDeclaredRequirements(java.lang.String)
 * @category BundleRevision
 */
public List<BundleRequirement> getDeclaredRequirements(
		final String namespace) {
	return namespace == null ? requirements.getAllValues()
			: requirements.lookup(namespace);
}
 

@Override
public List<BundleRequirement> getRequirements(String p1) {
    throw new UnsupportedOperationException();
}