java类org.osgi.framework.wiring.BundleRevision的实例源码

public static boolean isFragment(Bundle bundle) {
    return (bundle.adapt(BundleRevision.class).getTypes() & BundleRevision.TYPE_FRAGMENT) != 0;
}

public static List<BundleDefinition> getRequiredBundles(Bundle bundle) throws BundleException {
    List<BundleDefinition> rtn=new ArrayList<BundleDefinition>();
    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,name;
    int index,start,end,op;
    BundleDefinition bd;

    while(it.hasNext()){
        r = it.next();
        Iterator<Entry<String, String>> iit = r.getDirectives().entrySet().iterator();
        while(iit.hasNext()){
            e = iit.next();
            if(!"filter".equals(e.getKey())) continue;
            value=e.getValue();
            // name
            index=value.indexOf("(osgi.wiring.bundle");
            if(index==-1) continue;
            start=value.indexOf('=',index);
            end=value.indexOf(')',index);
            if(start==-1 || end==-1 || end<start) continue;
            name=value.substring(start+1,end).trim();
            rtn.add(bd=new BundleDefinition(name));

            // version
            op=-1;
            index=value.indexOf("(bundle-version");
            if(index==-1) continue;
            end=value.indexOf(')',index);

            start=value.indexOf("<=",index);
            if(start!=-1 && start<end) {
                op=VersionDefinition.LTE;
                start+=2;
            }
            else {
                start=value.indexOf(">=",index);
                if(start!=-1 && start<end) {
                    op=VersionDefinition.GTE;
                    start+=2;
                }
                else {
                    start=value.indexOf("=",index);
                    if(start!=-1 && start<end) {
                        op=VersionDefinition.EQ;
                        start++;
                    }
                }
            }

            if(op==-1 || start==-1 || end==-1 || end<start) continue;
            bd.setVersion(op,value.substring(start,end).trim());

        }
    }
    return rtn;
    // (&(osgi.wiring.bundle=slf4j.api)(bundle-version>=1.6.4))

}

public BundleInformation ( final Bundle bundle )
{
    this.bundle = bundle;
    this.bundleRevision = bundle.adapt ( BundleRevision.class );
}

public BundleRevision getBundleRevision ()
{
    return this.bundleRevision;
}

public boolean isFragment ()
{
    return ( this.bundleRevision.getTypes () & BundleRevision.TYPE_FRAGMENT ) > 0;
}

/**
 * Constructor for bundle capability resource
 *
 * @param path
 * @param bundleCapability
 */
public BundleCapabilityResource(Path path, BundleWiring hostWiring, BundleCapability bundleCapability) {
    super(path.addElements(uniqueCapabilityId(bundleCapability)));
    m_capability = bundleCapability;
    isPackage = m_capability.getNamespace().equals(OsgiResourceUtils.PackageNamespace.PACKAGE_NAMESPACE);
    List<Relation> relations = new ArrayList<Relation>();
    // calculate wires coming from this capability
    BundleRevision revision = m_capability.getRevision();
    if (revision != null) {
        String bundleId = Long.toString(revision.getBundle().getBundleId());
        //BundleWiring wiring = revision.getWiring();
        BundleWiring wiring = hostWiring;
        if (wiring != null) {
            List<BundleWire> allWires = wiring.getProvidedWires(m_capability.getNamespace());
            for (BundleWire wire : allWires) {
                if (wire.getCapability().equals(m_capability)) {
                    // and add a relation link
                    m_wires.add(wire);
                    String wireId = uniqueWireId(wire);
                    Path wirePath = BundleResourceManager.getInstance().getPath().addElements(Long.toString(hostWiring.getBundle().getBundleId()),
                            BundleResource.WIRES_PATH,
                            wireId
                    );
                    relations.add(new DefaultRelation(wirePath, Action.READ, wireId));
                }
            }
        }

        if (isPackage) {
            // add relation to package
            String packageId = uniqueCapabilityId(m_capability);
            Path packagePath = PackageResourceManager.getInstance().getPath().addElements(packageId);
            relations.add(new DefaultRelation(packagePath, Action.READ, PACKAGE_RELATION));
            // add relation to bundle export package header
            Path exportPackagePath = BundleResourceManager.getInstance().getPath()
                    .addElements(bundleId, BundleHeadersResource.HEADERS_PATH, BundleHeadersResource.EXPORT_PACKAGE, packageId);
            relations.add(new DefaultRelation(exportPackagePath, Action.READ, BundleHeadersResource.EXPORT_PACKAGE));
        }
        setRelations(relations);
    }
}