org.eclipse.xtext.common.types.access.impl.ClasspathTypeProvider Java Examples

/**
 * This constructor use the CogniCyrpt Core plugin lib folder as classpath
 */
public CrySLParser() {
	CrySLStandaloneSetup crySLStandaloneSetup = new CrySLStandaloneSetup();
	final Injector injector = crySLStandaloneSetup.createInjectorAndDoEMFRegistration();
	this.resourceSet = injector.getInstance(XtextResourceSet.class);
	List<File> jars = new ArrayList<>();
	String[] l = System.getProperty("java.class.path").split(";");

	URL[] classpath = new URL[l.length];
	for (int i = 0; i < classpath.length; i++) {
		try {
			classpath[i] = new File(l[i]).toURI().toURL();
		}
		catch (MalformedURLException e) {
			Activator.getDefault().logError("File path: " + jars.get(i) + " could not converted to java.net.URI object");
		}
	}

	URLClassLoader ucl = new URLClassLoader(classpath);
	this.resourceSet.setClasspathURIContext(new URLClassLoader(classpath));
	new ClasspathTypeProvider(ucl, this.resourceSet, null, null);
	this.resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE);
}
 

@Before
public void setUp() throws Exception {
	ResourceSet resourceSet = new ResourceSetImpl();
	Resource syntheticResource = new XMLResourceImpl(URI.createURI("http://synthetic.resource"));
	resourceSet.getResources().add(syntheticResource);
	typeProvider = new ClasspathTypeProvider(getClass().getClassLoader(), resourceSet, null, null);
}
 

@Override
protected ClasspathTypeProvider createClasspathTypeProvider(ResourceSet resourceSet) {
	ClassLoader classLoader = getClassLoader(resourceSet);
	CachingDeclaredTypeFactory actualFactoryToUse = reusedFactory;
	if (!isDefaultClassLoader(classLoader)) {
		actualFactoryToUse = newClassReaderTypeFactory(classLoader);
	}
	return new CachingClasspathTypeProvider(
			classLoader, 
			resourceSet, 
			getIndexedJvmTypeAccess(),
			actualFactoryToUse, services);
}
 

@Override
public ClasspathTypeProvider createTypeProvider(ResourceSet resourceSet) {
	if (resourceSet == null)
		throw new IllegalArgumentException("resourceSet may not be null.");
	ClasspathTypeProvider result = createClasspathTypeProvider(resourceSet);
	return result;
}
 

/**
 * Performs the actual installation of the JvmTypeProvider.
 */
private void internalInstallJvmTypeProvider(ResourceSet resourceSet, File tmpClassDirectory, boolean skipIndexLookup) {
	Iterable<String> classPathEntries = concat(asList(tmpClassDirectory.toString()), getClassPathEntries(), getSourcePathDirectories());
	classPathEntries = filter(classPathEntries, new Predicate<String>() {
		@Override
		public boolean apply(String input) {
			return !Strings.isEmpty(input.trim());
		}
	});
	
	Iterable<File> classpath = transform(classPathEntries, TO_FILE);
	if (log.isDebugEnabled()) {
		log.debug("classpath used for Xtend compilation : " + classpath);
	}
	ClassLoader parentClassLoader;
	if (useCurrentClassLoaderAsParent) {
		parentClassLoader = currentClassLoader;
	} else {
		if (isEmpty(bootClassPath)) {
			parentClassLoader = ClassLoader.getSystemClassLoader().getParent();
		} else {
			Iterable<File> bootClassPathEntries = transform(getBootClassPathEntries(), TO_FILE);
			parentClassLoader = new AlternateJdkLoader(bootClassPathEntries);
		}
	}
	jvmTypesClassLoader = createClassLoader(classpath, parentClassLoader);
	new ClasspathTypeProvider(jvmTypesClassLoader, resourceSet, skipIndexLookup ? null : indexedJvmTypeAccess, null);
	((XtextResourceSet) resourceSet).setClasspathURIContext(jvmTypesClassLoader);

	// for annotation processing we need to have the compiler's classpath as a parent.
	annotationProcessingClassLoader = createClassLoader(classpath, currentClassLoader);
	resourceSet.eAdapters().add(new ProcessorInstanceForJvmTypeProvider.ProcessorClassloaderAdapter(annotationProcessingClassLoader));
}
 

protected void installTypeProvider(Iterable<String> classPathRoots, XtextResourceSet resSet,
		IndexedJvmTypeAccess typeAccess) {
	URLClassLoader classLoader = createURLClassLoader(classPathRoots);
	new ClasspathTypeProvider(classLoader, resSet, typeAccess, null);
	resSet.setClasspathURIContext(classLoader);
}
 

@Test public void testCreateTypeProvider_01() {
	ClasspathTypeProvider typeProvider = factory.createTypeProvider();
	assertNotNull(typeProvider);
	assertNotNull(typeProvider.getResourceSet());
}
 

@Test public void testCreateTypeProvider_02() {
	ResourceSet resourceSet = new ResourceSetImpl();
	ClasspathTypeProvider typeProvider = factory.createTypeProvider(resourceSet);
	assertNotNull(typeProvider);
	assertEquals(resourceSet, typeProvider.getResourceSet());
}
 

@Test public void testCreateTypeProvider_03() {
	ClasspathTypeProvider typeProvider = factory.createTypeProvider();
	ResourceSet resourceSet = typeProvider.getResourceSet();
	Map<String, Object> map = resourceSet.getResourceFactoryRegistry().getProtocolToFactoryMap();
	assertEquals(typeProvider, map.get(URIHelperConstants.PROTOCOL));
}
 

@Test public void testFindTypeProvider_02() {
	ResourceSet resourceSet = new ResourceSetImpl();
	ClasspathTypeProvider typeProvider = factory.createTypeProvider(resourceSet);
	assertSame(typeProvider, factory.findTypeProvider(resourceSet));
}
 

@Before
public void setUp() throws Exception {
	resourceSet = new ResourceSetImpl();
	typeProvider = new ClasspathTypeProvider(getClass().getClassLoader(), resourceSet, null, null);
}
 

protected ClasspathTypeProvider getTypeProvider() {
	return typeProvider;
}
 

@Override
public ClasspathBasedTypeScope createTypeScope(IJvmTypeProvider typeProvider, Predicate<IEObjectDescription> filter) {
	return new ClasspathBasedTypeScope((ClasspathTypeProvider) typeProvider, qualifiedNameConverter, filter);
}
 

public ClasspathBasedTypeScope(ClasspathTypeProvider typeProvider, IQualifiedNameConverter qualifiedNameConverter, Predicate<IEObjectDescription> filter) {
	super(typeProvider, qualifiedNameConverter, filter);
}
 

protected ClasspathTypeProvider createClasspathTypeProvider(ResourceSet resourceSet) {
	return new ClasspathTypeProvider(getClassLoader(resourceSet), resourceSet, getIndexedJvmTypeAccess(), services);
}
 

@Override
public ClasspathTypeProvider createTypeProvider() {
	return (ClasspathTypeProvider) super.createTypeProvider();
}