public class LoadModelResourceOperation implements IRunnableWithProgress {

	private final ResourceSet resourceSet;

	private final URI fileURI;

	public LoadModelResourceOperation(URI fileURI) {
		this.fileURI = fileURI;

		this.resourceSet = new ResourceSetImpl();

		// Register the appropriate resource factory to handle all file
		// extensions.
		this.resourceSet
				.getResourceFactoryRegistry()
				.getExtensionToFactoryMap()
				.put(Resource.Factory.Registry.DEFAULT_EXTENSION,
						new WorkerchainResourceFactoryImpl());

		// Register the package to ensure it is available during loading.
		this.resourceSet.getPackageRegistry().put(WorkerchainPackage.eNS_URI,
				WorkerchainPackage.eINSTANCE);
	}

	@Override
	public void run(IProgressMonitor progressMonitor) {
		try {
			// Demand load resource for this file.
			//
			Resource resource = resourceSet.getResource(fileURI, true);
			// Resource resource = new ResourceFactoryImpl()
			// .createResource(fileURI);

			// no options needed
			if (!resource.isLoaded()) {
				resource.load(null);
			}
		} catch (RuntimeException exception) {
			System.out.println("Problem loading " + fileURI);
			exception.printStackTrace();
		} catch (IOException e) {
			System.out.println("Problem loading resource" + fileURI);
			e.printStackTrace();
		}
	}

}

try {
						PlatformUI
								.getWorkbench()
								.getProgressService()
								.run(false, false,
										new LoadModelResourceOperation(fileUri));
					} catch (InvocationTargetException e) {
						e.printStackTrace();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}

					WorkerchainEditorAdvisor.openEditor(
							PlatformUI.getWorkbench(), fileUri);

	public void createModel() {
		URI resourceURI = EditUIUtil.getURI(getEditorInput());
		Exception exception = null;
		Resource resource = null;
		try {
			// Load the resource through the editing domain.
			//
			resource = editingDomain.getResourceSet().getResource(resourceURI,
					true);
		} catch (Exception e) {
			exception = e;
			resource = editingDomain.getResourceSet().getResource(resourceURI,
					false);
		}

		Diagnostic diagnostic = analyzeResourceProblems(resource, exception);
		if (diagnostic.getSeverity() != Diagnostic.OK) {
			resourceToDiagnosticMap.put(resource,
					analyzeResourceProblems(resource, exception));
		}
		editingDomain.getResourceSet().eAdapters()
				.add(problemIndicationAdapter);
	}

 
resource = editingDomain.getResourceSet().getResource(resourceURI,
					true);

protected void initializeEditingDomain() {
		// Create an adapter factory that yields item providers.
		//
		adapterFactory = new ComposedAdapterFactory(
				ComposedAdapterFactory.Descriptor.Registry.INSTANCE);

		adapterFactory
				.addAdapterFactory(new ResourceItemProviderAdapterFactory());
		adapterFactory
				.addAdapterFactory(new WorkerchainItemProviderAdapterFactory());
		adapterFactory
				.addAdapterFactory(new ReflectiveItemProviderAdapterFactory());

		// Create the command stack that will notify this editor as commands are
		// executed.
		//
		BasicCommandStack commandStack = new BasicCommandStack();

		// Add a listener to set the most recent command's affected objects to
		// be the selection of the viewer with focus.
		//
		commandStack.addCommandStackListener(new CommandStackListener() {
			public void commandStackChanged(final EventObject event) {
				getContainer().getDisplay().asyncExec(new Runnable() {
					public void run() {
						firePropertyChange(IEditorPart.PROP_DIRTY);

						// Try to select the affected objects.
						//
						Command mostRecentCommand = ((CommandStack) event
								.getSource()).getMostRecentCommand();
						if (mostRecentCommand != null) {
							setSelectionToViewer(mostRecentCommand
									.getAffectedObjects());
						}
						for (Iterator<PropertySheetPage> i = propertySheetPages
								.iterator(); i.hasNext();) {
							PropertySheetPage propertySheetPage = i.next();
							if (propertySheetPage.getControl().isDisposed()) {
								i.remove();
							} else {
								propertySheetPage.refresh();
							}
						}
					}
				});
			}
		});

		// Create the editing domain with a special command stack.
		//
		editingDomain = new AdapterFactoryEditingDomain(adapterFactory,
				commandStack, new HashMap<Resource, Boolean>());
	}