import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
/**
 * initializes the online repository
 * information comes from the pathvisio.xml file
 * in the repository
 * such an XML file can contain more than one 
 * repository
 */
private void setUpOnlineRepo(Repository repo, URL url) {
	if(repo != null) {
		Logger.log.info("Initialize repository " + url);
		
		List<PVRepository> repositories = readPluginInfo(url);
		if(repositories != null) {
			for(PVRepository r : repositories) {
				// set to installed if bundle is present in local repository
				for(BundleVersion version : r.getBundleVersions()) {
					if(localHandler.containsBundle(version.getSymbolicName()) != null) {
						version.getBundle().setInstalled(true);
					}
				}
			}
			// a database can contain more than one repository
			// all of them will be added separately
			onlineRepos.addAll(repositories);
		}
	}
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
private BndRunOption(File bndRunFile, URL repoURL) throws Exception {
    props.load(new FileInputStream(bndRunFile));
    DataModelHelperImpl dataModelHelper = new DataModelHelperImpl();
    Repository repository = dataModelHelper.repository(repoURL);
    addRunBundles(repository);
    addSystemPackages(options, props);
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
private void addRunBundles(Repository repository) {
    BundleUris bundleUris = new BundleUris(repository);
    String runBundles = (String)props.get("-runbundles");
    List<BundleRef> bundles = RunBundles.parse(runBundles);
    
    for (BundleRef bundle : bundles) {
        String uri = bundleUris.getUri(bundle.symbolicName, bundle.version);
        options.add(CoreOptions.bundle(uri));
    }
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
@Override
public Collection<String> getRemoteRepositories() {
    ServiceReference ref = bundleContext.getServiceReference(RepositoryAdmin.class.getName());
    RepositoryAdmin repoAdmin = (RepositoryAdmin)bundleContext.getService(ref);
    Repository[] repositories = repoAdmin.listRepositories();
    List<String> results = new ArrayList<>();
    for (Repository repository : repositories) {
        results.add(repository.getURI());
    }
    return results;
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
public KonektiFelixResource(String id, Long bundleId, String symbolicName, String version,
		String presentationName, Repository repository, String url,
		Requirement[] requeriments, Capability[] capabilities, String[] categories,
		String licenseUrl, String description, String documentation,
		String copyright, String sourceUrl, String size, String[] keys, Resource resource,
		String bundleStatus, Bundle bundle) {
	super();
	this.id = id;
	this.bundleId = bundleId;
	this.symbolicName = symbolicName;
	this.version = version;
	this.presentationName = presentationName;
	this.repository = repository;
	this.url = url;
	this.requeriments = requeriments;
	this.capabilities = capabilities;
	this.categories = categories;
	this.licenseUrl = licenseUrl;
	this.description = description;
	this.documentation = documentation;
	this.copyright = copyright;
	this.sourceUrl = sourceUrl;
	this.size = size;
	this.keys = keys;
	this.resource = resource;
	this.bundleStatus = bundleStatus;
	this.bundle = bundle;
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
BundleUris(Repository repository) {
    for (Resource res : repository.getResources()) {
        bundleUri.put(getKey(res) , res.getURI());
    }
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
public boolean getAllPossibleValues(final List<Completion> completions,
        final Class<?> requiredType, final String originalUserInput,
        final String optionContext, final MethodTarget target) {
    boolean local = false;
    boolean obr = false;

    if ("".equals(optionContext)) {
        local = true;
    }

    if (optionContext.contains("local")) {
        local = true;
    }

    if (optionContext.contains("obr")) {
        obr = true;
    }

    if (local) {
        final Bundle[] bundles = context.getBundleContext().getBundles();
        if (bundles != null) {
            for (final Bundle bundle : bundles) {
                final String bsn = bundle.getSymbolicName();
                if (bsn != null && bsn.startsWith(originalUserInput)) {
                    completions.add(new Completion(bsn));
                }
            }
        }
    }

    if (obr) {
        final Repository[] repositories = repositoryAdmin
                .listRepositories();
        if (repositories != null) {
            for (final Repository repository : repositories) {
                final Resource[] resources = repository.getResources();
                if (resources != null) {
                    for (final Resource resource : resources) {
                        if (resource.getSymbolicName().startsWith(
                                originalUserInput)) {
                            completions.add(new Completion(resource
                                    .getSymbolicName()));
                        }
                    }
                }
            }
        }
    }

    return false;
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
/**
 * @return the repository
 */
public Repository getRepository() {
	return repository;
}
 

import org.apache.felix.bundlerepository.Repository; //导入依赖的package包/类
/**
 * @param repository the repository to set
 */
public void setRepository(Repository repository) {
	this.repository = repository;
}