Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright 2012 Liferay Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 
 
 package org.phidias.compile;
 
 
 import java.net.URI;
 import java.net.URL;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
 
 
 public class BundleJavaManager
 	implements Constants {
 
 	public BundleJavaManager(Bundle bundleJavaFileManager javaFileManager)
 		throws IOException {
 
 		this(bundlejavaFileManagernullfalse);
 	}
 
 			Bundle bundleJavaFileManager javaFileManager,
 			List<Stringoptions)
 		throws IOException {
 
 		this(bundlejavaFileManageroptionsfalse);
 	}
 
 			Bundle bundleJavaFileManager javaFileManager,
 			List<Stringoptionsboolean strict)
 		throws IOException {
 
 		super(javaFileManager);
 
 		 = bundle;
 		 = javaFileManager;
 		 = new TPhLog();
 
 		setOptions(options);
 
 		 = strict;
 
 			"Initializing compilation in OSGi for bundle " +
 
 
 
 
 		List<BundleWireprovidedWires = .getRequiredWires(null);
 
 			"Dependent BundleWirings included in this BundleJavaManager " +
 				"context: ");
 
 
 		for (BundleWire bundleWire : providedWires) {
 			BundleWiring providerWiring = bundleWire.getProviderWiring();
			if (.contains(providerWiring)) {
				continue;
			}
			Bundle curBundle = providerWiring.getBundle();
			if ( && (curBundle.getBundleId() == 0)) {
				 = providerWiring;
			}
				"\t" + curBundle.getSymbolicName() + "-" +
					curBundle.getVersion());
			.add(providerWiring);
		}
		if ( && ( != null)) {
		}
	}
	public void addBundleRequirement(BundleRequirement bundleRequirement) {
		if (.contains(bundleRequirement)) {
			return;
		}
		.add(bundleRequirement);
	}
	public void addBundleWiring(BundleWiring bundleWiring) {
		if (.contains(bundleWiring)) {
			return;
		}
		.add(bundleWiring);
	}
		return ;
	}
	public ClassLoader getClassLoader(Location location) {
		if (location != .) {
		}
		return getClassLoader();
	}
	public String inferBinaryName(Location locationJavaFileObject file) {
		if ((location == .) &&
			(file instanceof BundleJavaFileObject)) {
			BundleJavaFileObject bundleJavaFileObject =
			.log("Infering binary name from " + bundleJavaFileObject);
			return bundleJavaFileObject.inferBinaryName();
		}
		return .inferBinaryName(locationfile);
	}
			Location locationString packageNameSet<Kindkinds,
			boolean recurse)
		throws IOException {
		List<JavaFileObjectjavaFileObjects = new ArrayList<JavaFileObject>();
		if (location == .) {
				"List available sources for {location=" + location +
					", packageName=" + packageName + ", kinds=" + kinds +
						", recurse=" + recurse + "}");
		}
		String packagePath = packageName.replace('.''/');
		if (!packageName.startsWith() &&
			(location == .)) {
				packageNamekindsrecursepackagePathjavaFileObjects);
		}
		// When not in strict mode, the following ensures that if a standard
		// classpath location has been provided we include it. It allows the
		// framework to compile against libraries not deployed as OSGi bundles.
		// This is also needed in cases where the system.bundle exports extra
		// packages via the property 'org.osgi.framework.system.packages.extra'
		// or via extension bundles (fragments) which only supplement its
		// 'Export-Package' directive.
		if (packageName.startsWith() ||
			(location != .) ||
			(javaFileObjects.isEmpty() && hasPackageCapability(packageName))) {
			Iterable<JavaFileObjectlocalJavaFileObjects =
				.list(locationpackagePathkindsrecurse);
			for (JavaFileObject javaFileObject : localJavaFileObjects) {
				if (location == .) {
					.log("\t" + javaFileObject);
				}
				javaFileObjects.add(javaFileObject);
			}
		}
		return javaFileObjects;
	}
	public void setResourceResolver(ResourceResolver resourceResolver) {
		 = resourceResolver;
	}
	private String getClassNameFromPath(URL resourceString packageName) {
		String className = resource.getPath();
		if (resource.getProtocol().equals("jar")) {
			int pos = className.indexOf("!");
			className = className.substring(pos + 1);
		}
		int x = className.indexOf(packageName);
		int y = className.indexOf('.');
		className = className.substring(xy).replace('/''.');
		if (className.startsWith()) {
			className = className.substring(1);
		}
		return className;
	}
		URL resourceURLString packagePath) {
		String protocol = resourceURL.getProtocol();
		String className = getClassNameFromPath(resourceURLpackagePath);
		if (protocol.equals("bundle") || protocol.equals("bundleresource")) {
			try {
				return new BundleJavaFileObject(resourceURL.toURI(), className);
			}
			catch (Exception e) {
			}
		}
		else if (protocol.equals("jar")) {
			try {
				JarURLConnection jarUrlConnection =
				URI uri = jarUrlConnection.getJarFileURL().toURI();
				String entryName = jarUrlConnection.getEntryName();
				return new JarJavaFileObject(
					uriclassNameresourceURLentryName);
			}
			catch (Exception e) {
			}
		}
		return null;
	}
		if ( != null) {
		}
	}
	private boolean hasPackageCapability(String packageName) {
		if (!) {
			return true;
		}
		// We only need to check if there is a matching system bundle capability
		// if mode is strict. Otherwise, allow loading classes from the defined
		// classpath.
		return ( != null) &&
	}
	private boolean hasPackageCapability(
		List<BundleCapabilitycapabilitiesString packageName) {
		for (BundleCapability capability : capabilities) {
			Map<StringObjectattributes = capability.getAttributes();
			Object packageAttribute = attributes.get(
			if ((packageAttribute != null) &&
				packageAttribute.equals(packageName)) {
				return true;
			}
		}
		return false;
	}
	private void list(
		String packagePathKind kindint optionsBundleWiring bundleWiring,
		List<JavaFileObjectjavaFileObjects) {
		ResourceResolver resourceResolver = getResourceResolver();
		Collection<Stringresources = resourceResolver.resolveResources(
			bundleWiringpackagePath.concat(kind.extension), options);
		if ((resources == null) || resources.isEmpty()) {
			return;
		}
		for (String resourceName : resources) {
			URL resourceURL = resourceResolver.getResource(
				bundleWiringresourceName);
			JavaFileObject javaFileObject = getJavaFileObject(
				resourceURLpackagePath);
			if (javaFileObject == null) {
					"\tCould not create JavaFileObject for {" + resourceURL +
						"}");
				continue;
			}
			.log("\t" + javaFileObject);
			javaFileObjects.add(javaFileObject);
		}
	}
	private void listFromDependencies(
		String packageNameSet<Kindkindsboolean recurse,
		String packagePathList<JavaFileObjectjavaFileObjects) {
		int options = recurse ? . : 0;
		for (Kind kind : kinds) {
			if (kind.equals(.)) {
				for (BundleWiring bundleWiring : ) {
						packagePathkindoptionsbundleWiring,
						javaFileObjects);
				}
			}
			if (javaFileObjects.isEmpty()) {
					packagePathkindoptionsjavaFileObjects);
			}
		}
	}
	private void setOptions(List<Stringoptions) {
		if (options == null) {
			return;
		}
		.addAll(options);
		}
	}
	private Bundle _bundle;
	private TPhLog _log;
	private List<String_options = new ArrayList<String>();
	private boolean _strict;
New to GrepCode? Check out our FAQ X