org.eclipse.xtext.util.RuntimeIOException Java Examples

@Test
public void testMarkNotSupported() throws Exception {
	fsa.generateFile("tmp/bar", new StringInputStream("you should never see this"));
	InputStream input = new StringInputStream("foo") {
		@Override
		public boolean markSupported() {
			return false;
		}
		@Override
		public synchronized void reset() {
			throw new RuntimeIOException("mark/reset not supported");
		}
	};
	fsa.generateFile("tmp/bar", input);
	IFolder dir = project.getFolder("src-gen/tmp");
	assertTrue(dir.exists());
	IFile file = dir.getFile("bar");
	assertTrue(file.exists());
	assertEquals("foo", fsa.readTextFile("tmp/bar"));
}
 

@Override
public ResourceStorageLoadable getOrCreateResourceStorageLoadable(StorageAwareResource resource) {
	try {
		ResourceSet resourceSet = resource.getResourceSet();
		ResourceStorageProviderAdapter stateProvider = getResourceStorageProviderAdapter(resourceSet);
		if (stateProvider != null) {
			ResourceStorageLoadable loadable = stateProvider.getResourceStorageLoadable(resource);
			if (loadable != null)
				return loadable;
		}
		if (resourceSet.getURIConverter().exists(getBinaryStorageURI(resource.getURI()),
				Collections.emptyMap())) {
			return createResourceStorageLoadable(resourceSet.getURIConverter()
					.createInputStream(getBinaryStorageURI(resource.getURI())));
		}
		return createResourceStorageLoadable(
				getFileSystemAccess(resource).readBinaryFile(computeOutputPath(resource)));
	} catch (IOException e) {
		throw new RuntimeIOException(e);
	}
}
 

@Override
public void scan(URI root, IAcceptor<URI> acceptor) {
	File rootFile = URIUtils.toFile(root);
	if (rootFile.isDirectory()) {
		try {
			Path rootPath = rootFile.toPath();
			if (acceptor instanceof FileVisitingAcceptor) {
				Files.walkFileTree(rootPath, (FileVisitingAcceptor) acceptor);
			} else {
				Files.walk(rootPath).forEach(p -> {
					File file = p.toFile();
					if (!file.isDirectory()) {
						acceptor.accept(new FileURI(p.toFile()).toURI());
					}
				});
			}
		} catch (IOException e) {
			throw new RuntimeIOException(e);
		}
	}
}
 

@Override
public void generateFile(String fileName, String outputName, CharSequence contents) {
	if (monitor.isCanceled())
		throw new OperationCanceledException();
	OutputConfiguration outputConfig = getOutputConfig(outputName);

	if (!ensureOutputConfigurationDirectoryExists(outputConfig))
		return;

	IFile file = getFile(fileName, outputName);
	if (file == null)
		return;
	IFile traceFile = getTraceFile(file);
	try {
		String encoding = getEncoding(file);
		CharSequence postProcessedContent = postProcess(fileName, outputName, contents, encoding);
		String contentsAsString = postProcessedContent.toString();
		StringInputStream newContent = getInputStream(contentsAsString, encoding);
		generateFile(file, newContent, traceFile, postProcessedContent, outputConfig);
	} catch (CoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.4
 */
protected boolean ensureOutputConfigurationDirectoryExists(OutputConfiguration outputConfig) {
	IContainer container = getContainer(outputConfig);
	if (container == null) {
		return false;
	}
	if (!container.exists()) {
		if (outputConfig.isCreateOutputDirectory()) {
			try {
				createContainer(container);
				return true;
			} catch (CoreException e) {
				throw new RuntimeIOException(e);
			}
		} else {
			return false;
		}
	}
	return true;
}
 

@Override
public void generateFile(String fileName, String outputConfigName, CharSequence contents) throws RuntimeIOException {
	File file = getFile(fileName, outputConfigName);
	if (!getOutputConfig(outputConfigName).isOverrideExistingResources() && file.exists()) {
		return;
	}
	try {
		createFolder(file.getParentFile());
		String encoding = getEncoding(getURI(fileName, outputConfigName));
		OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file), encoding);
		try {
			writer.append(postProcess(fileName, outputConfigName, contents, encoding));
			if(callBack != null) 
				callBack.fileAdded(file);
			if (writeTrace)
				generateTrace(fileName, outputConfigName, contents);
		} finally {
			writer.close();
		}
	} catch (IOException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.4
 */
@Override
public void generateFile(String fileName, String outputCfgName, InputStream content) throws RuntimeIOException {
	File file = getFile(fileName, outputCfgName);
	if (!getOutputConfig(outputCfgName).isOverrideExistingResources() && file.exists()) {
      return;
	}
	try {
		createFolder(file.getParentFile());
		OutputStream out = new BufferedOutputStream(new FileOutputStream(file));
		try {
			ByteStreams.copy(content, out);
		} finally {
			try {
				out.close();
				if(callBack != null) 
					callBack.fileAdded(file);
			} finally {
				content.close();
			}
		}
	} catch (IOException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.4
 */
@Override
public InputStream readBinaryFile(String fileName, String outputCfgName) throws RuntimeIOException {
	File file = getFile(fileName, outputCfgName);
	try {
		return new BufferedInputStream(new FileInputStream(file));
	} catch (FileNotFoundException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.7
 */
public InputStream readBinaryFile(String fileName, String outputCfgName, IProgressMonitor progressMonitor) throws RuntimeIOException {
	try {
		IFile file = getFile(fileName, outputCfgName, progressMonitor);
		return new BufferedInputStream(file.getContents());
	} catch (CoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

public static IFolder createSubFolder(IProject project, String folderName) throws CoreException {
	IFolder folder = project.getFolder(folderName);
	if (folder.exists()) {
		folder.delete(true, null);
	}
	try {
		return createFolder(folder.getFullPath());
	} catch (Exception e) {
		throw new RuntimeIOException(e);
	}
}
 

@Override
protected boolean ensureOutputConfigurationDirectoryExists(OutputConfiguration outputConfig) {
	try {
		if (super.ensureOutputConfigurationDirectoryExists(outputConfig)) {
			IContainer container = getContainer(outputConfig);
			addToSourceFolders(container);
			return true;
		}
		return false;
	} catch (CoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

private void writePreferences(OutputConfiguration configuration,
		IProject project) {
	ProjectScope projectPreferences = new ProjectScope(project);
	IEclipsePreferences languagePreferences = projectPreferences
			.getNode("org.eclipse.xtend.core.Xtend");
	languagePreferences.putBoolean(
			OptionsConfigurationBlock.isProjectSpecificPropertyKey(BuilderConfigurationBlock.PROPERTY_PREFIX), true);
	languagePreferences.putBoolean(
			getKey(configuration, INSTALL_DSL_AS_PRIMARY_SOURCE),
			configuration.isInstallDslAsPrimarySource());
	languagePreferences.putBoolean(
			getKey(configuration, HIDE_LOCAL_SYNTHETIC_VARIABLES),
			configuration.isHideSyntheticLocalVariables());
	languagePreferences.putBoolean(
			getKey(configuration, USE_OUTPUT_PER_SOURCE_FOLDER),
			true);
	for (SourceMapping sourceMapping : configuration.getSourceMappings()) {
		languagePreferences.put(
				getOutputForSourceFolderKey(configuration,
						sourceMapping.getSourceFolder()),
				Strings.nullToEmpty(sourceMapping.getOutputDirectory()));
	}

	try {
		languagePreferences.flush();
	} catch (BackingStoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

protected File createTempDir() {
	if (temporaryFolder != null && temporaryFolder.isInitialized()) {
		try {
			return temporaryFolder.newFolder();
		} catch (IOException e) {
			throw new RuntimeIOException(e);
		}
	}
	return com.google.common.io.Files.createTempDir();
}
 

@Override
public void generateFile(String fileName, String outputCfgName, InputStream content) throws RuntimeIOException {
	try {
		URI uri = getURI(fileName, outputCfgName);
		try (OutputStream out = converter.createOutputStream(uri)) {
			ByteStreams.copy(beforeWrite.beforeWrite(uri, outputCfgName, content), out);
		}
	} catch (IOException t) {
		throw new RuntimeIOException(t);
	}
}
 

@Override
public InputStream readBinaryFile(String fileName, String outputCfgName) throws RuntimeIOException {
	try {
		URI uri = getURI(fileName, outputCfgName);
		return beforeRead.beforeRead(uri, converter.createInputStream(uri));
	} catch (IOException t) {
		throw new RuntimeIOException(t);
	}
}
 

/**
 * @since 2.4
 */
@Override
public void generateFile(String fileName, String outputCfgName, InputStream content) {
	try {
		try {
			byte[] byteArray = ByteStreams.toByteArray(content);
			files.put(getFileName(fileName, outputCfgName), byteArray);
		} finally {
			content.close();
		}
	} catch (IOException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.4
 */
@Override
public InputStream readBinaryFile(String fileName, String outputCfgName) throws RuntimeIOException {
	String name = getFileName(fileName, outputCfgName);
	Object contents = files.get(name);
	if (contents == null)
		throw new RuntimeIOException("File not found: " + name);
	if (contents instanceof byte[])
		return new ByteArrayInputStream((byte[]) contents);
	if (contents instanceof CharSequence)
		return new StringInputStream(contents.toString());
	throw new RuntimeIOException("Unknown File Data Type: " + contents.getClass() + " File: " + name);
}
 

/**
 * @since 2.4
 */
@Override
public CharSequence readTextFile(String fileName, String outputCfgName) throws RuntimeIOException {
	String name = getFileName(fileName, outputCfgName);
	Object contents = files.get(name);
	if (contents == null)
		throw new RuntimeIOException("File not found: " + name);
	if (contents instanceof CharSequence)
		return (CharSequence) contents;
	if (contents instanceof byte[])
		throw new RuntimeIOException("Can not read a binary file using readTextFile(). File: " + name);
	throw new RuntimeIOException("Unknown File Data Type: " + contents.getClass() + " File: " + name);
}
 

@Override
protected IResourceDescription internalGetResourceDescription(final Resource resource,
		IDefaultResourceDescriptionStrategy strategy) {
	if (resource instanceof DerivedStateAwareResource) {
		DerivedStateAwareResource res = (DerivedStateAwareResource) resource;
		if (!res.isLoaded()) {
			try {
				res.load(res.getResourceSet().getLoadOptions());
			} catch (IOException e) {
				throw new RuntimeIOException(e);
			}
		}
		boolean isInitialized = res.fullyInitialized || res.isInitializing;
		try {
			if (!isInitialized) {
				res.eSetDeliver(false);
				res.installDerivedState(true);
			}
			IResourceDescription description = createResourceDescription(resource, strategy);
			if (!isInitialized) {
				// eager initialize
				for (IEObjectDescription desc : description.getExportedObjects()) {
					desc.getEObjectURI();
				}
			}
			return description;
		} finally {
			if (!isInitialized) {
				if (log.isDebugEnabled())
					log.debug("Discarding inferred state for "+resource.getURI());
				res.discardDerivedState();
				res.eSetDeliver(true);
			}
		}
	} else {
		if (log.isDebugEnabled())
			log.debug("Invalid configuration. DerivedStateAwareResourceDescriptionManager was registered, but resource was a " + resource.getClass().getName());
		return super.internalGetResourceDescription(resource, strategy);
	}
}
 

@Override
protected boolean ensureOutputConfigurationDirectoryExists(OutputConfiguration outputConfig) {
	try {
		if (super.ensureOutputConfigurationDirectoryExists(outputConfig)) {
			final IContainer container = getContainer(outputConfig);
			addToSourceFolders(container);
			return true;
		}
		return false;
	} catch (CoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

protected File createTempDir() {
	if (temporaryFolder != null && temporaryFolder.isInitialized()) {
		try {
			return temporaryFolder.newFolder();
		} catch (IOException e) {
			throw new RuntimeIOException(e);
		}
	}
	return com.google.common.io.Files.createTempDir();
}
 

public static IFolder createSubFolder(IProject project, String folderName) throws CoreException {
	IFolder folder = project.getFolder(folderName);
	if (folder.exists()) {
		folder.delete(true, null);
	}
	try {
		return IResourcesSetupUtil.createFolder(folder.getFullPath());
	} catch (Exception e) {
		throw new RuntimeIOException(e);
	}
}
 

@Override
public void deleteFile(String fileName, String outputName) {
	try {
		IFile file = getFile(fileName, outputName);
		deleteFile(file, outputName, monitor);
	} catch (CoreException e) {
		throw new RuntimeIOException(e);
	}
}
 

protected StringInputStream getInputStream(String contentsAsString, String encoding) {
	try {
		return new StringInputStream(contentsAsString, encoding);
	} catch (UnsupportedEncodingException e) {
		throw new RuntimeIOException(e);
	}
}
 

/**
 * @since 2.9
 */
@Override
public boolean isFile(String path) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).isFile(path, new NullProgressMonitor());
	}
	return delegate.isFile(path);
}
 

/**
 * @since 2.9
 */
@Override
public boolean isFile(String path, String outputConfigurationName) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).isFile(path, outputConfigurationName, new NullProgressMonitor());
	}
	return delegate.isFile(path, outputConfigurationName);
}
 

@Override
public CharSequence readTextFile(String fileName) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).readTextFile(fileName, new NullProgressMonitor());
	}
	return delegate.readTextFile(fileName);
}
 

@Override
public CharSequence readTextFile(String fileName, String outputCfgName) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).readTextFile(fileName, outputCfgName, new NullProgressMonitor());
	}
	return delegate.readTextFile(fileName, outputCfgName);
}
 

@Override
public InputStream readBinaryFile(String fileName) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).readBinaryFile(fileName, new NullProgressMonitor());
	}
	return delegate.readBinaryFile(fileName);
}
 

@Override
public InputStream readBinaryFile(String fileName, String outputCfgName) throws RuntimeIOException {
	if (delegate instanceof EclipseResourceFileSystemAccess2) {
		return ((EclipseResourceFileSystemAccess2) delegate).readBinaryFile(fileName, outputCfgName, new NullProgressMonitor());
	}
	return delegate.readBinaryFile(fileName, outputCfgName);
}