public EditModel createEditModelForRead(String editModelID, EMFWorkbenchContext context, Map params) { EditModel editModel = new EditModel(editModelID, context, true); editModel.setAccessAsReadForUnKnownURIs(loadKnownResourcesAsReadOnly); return editModel; }
protected void processResource(Resource aResource) { if (aResource != null && !getResources().contains(aResource)) { if (aResource instanceof ReferencedResource) { access((ReferencedResource) aResource); // We need a better way to pass this through the save options instead. // We also need to make this dynamic based on the project target ((ReferencedResource) aResource).setFormat(CompatibilityXMIResource.FORMAT_MOF5); } else if (aResource instanceof CompatibilityXMIResource) { ((CompatibilityXMIResource) aResource).setFormat(CompatibilityXMIResource.FORMAT_MOF5); } addResource(aResource); } }
/** * Subclasses may override {@link #primSave} */ public final void save(IProgressMonitor monitor, Object accessorKey) { assertPermissionToSave(accessorKey); getSaveHandler().access(); try { IWorkspaceRunnable runnable = new IWorkspaceRunnable() { public void run(IProgressMonitor aMonitor) { primSave(aMonitor); } }; runSaveOperation(runnable, monitor); } catch (SaveFailedException ex) { getSaveHandler().handleSaveFailed(ex, monitor); } catch (Exception ex) { ex.printStackTrace(); } finally { getSaveHandler().release(); } }
/** * This is the API that clients should use when they have an intent to modify a particular * resource. You should only access the resources through the J2EEEditModel that is returned by * this method if you have the intent to modify. * * @see J2EEEditModel */ public final EditModel getEditModelForWrite(String editModelID, Object accessorKey, Map params) { EditModel editModel = getExistingEditModel(editModelID, params, false); if (null == editModel) { editModel = createEditModelForWrite(editModelID, params); synchronized (editModel) { cacheEditModel(editModel, params); editModel.access(accessorKey); } } else { synchronized (editModel) { if (editModel.isDisposed() || editModel.isDisposing()) { editModel = createEditModelForWrite(editModelID, params); cacheEditModel(editModel, params); } editModel.access(accessorKey); } } return editModel; }
public void removeChild(EditModel.Reference reference, Object accessorKey) { ComposedAccessorKey composedAccessorKey = ComposedAccessorKey.getComposedAccessorKey(accessorKey, this); EditModel editModel = (EditModel) getChildrenMap().remove(reference); if (editModel != null) { editModel.releaseAccess(composedAccessorKey); editModel.removeListener(this); getChildren().remove(editModel); } }
public void identifierChanged(EnablementIdentifierEvent evt) { if (evt.hasEnabledChanged()) { EditModelEvent editModelEvent = new EditModelEvent(EditModelEvent.KNOWN_RESOURCES_ABOUT_TO_CHANGE, this); notifyListeners(editModelEvent); IEnablementIdentifier id = evt.getIdentifier(); if (id.isEnabled()) addKnownResources(id); else removeKnownResources(id); editModelEvent = new EditModelEvent(EditModelEvent.KNOWN_RESOURCES_CHANGED, this); notifyListeners(editModelEvent); } }
/** * Subclasses should override and add URIs (type URI) of known resources. You must add resources * that have references to other known resources first so they will be released first. */ protected void initializeKnownResourceUris() { knownResourceUris = new ArrayList(); preloadResourceUris = new ArrayList(); EditModelResource res = null; Collection editModelResources = EditModelRegistry.getInstance().getEditModelResources(getEditModelID()); Iterator iter = editModelResources.iterator(); while (iter.hasNext()) { res = (EditModelResource) iter.next(); addEditModelResource(res); } Collection resourceExtensions = EditModelRegistry.getInstance().getEditModelExtensions(getEditModelID()); /* bug 170690 - initialize knownResourceExtensions if necessary, and change reference from iter to it */ if (knownResourceExtensions == null) { knownResourceExtensions = new ArrayList(); } if (!resourceExtensions.isEmpty()) { knownResourceExtensions.addAll(resourceExtensions); Iterator it = resourceExtensions.iterator(); ResourceSetWorkbenchEditSynchronizer sync = (ResourceSetWorkbenchEditSynchronizer) getEmfContext().getResourceSet().getSynchronizer(); while (it.hasNext()) { sync.enableAutoload(it.next().toString()); } } }
public void editModelChanged(EditModelEvent anEvent) { switch (anEvent.getEventCode()) { case EditModelEvent.UNLOADED_RESOURCE : if (anEvent.getChangedResources().contains(resource) && ! resource.isLoaded()) { try { resource.load(resource.getResourceSet().getLoadOptions()); } catch (IOException ioe) { JptCorePlugin.log(ioe); } } break; case EditModelEvent.REMOVED_RESOURCE : if (anEvent.getChangedResources().contains(resource)) { anEvent.getEditModel().removeListener(this); } break; // case EditModelEvent.SAVE : // case EditModelEvent.PRE_DISPOSE : } } // commenting out for now - this *was* a workaround for 202190, but with ArtifactEdit
public EditModel.Reference addChild(String editModelID, Map params, ComposedAccessorKey composedAccessorKey) { EditModel editModel = getEmfContext().getEditModelForWrite(editModelID, composedAccessorKey, params); editModel.addListener(this); getChildrenMap().put(editModel.getReference(), editModel); getChildren().add(editModel); return editModel.getReference(); }
/** * An {@link EditModel} is being accessed so we will want * to update the lru and access the editModel which will hold * a reference count. * @param editModel - The {@link EditModel} that we want to place * in the least used cache. */ public void access(EditModel editModel) { boolean shouldAccess = true; synchronized (lru) { if (lru.contains(editModel)) { moveToEnd(editModel); shouldAccess = false; } } if (shouldAccess) { synchronized (lru) { editModel.access(this); lru.add(editModel); } } }
/** * @deprecated use createResource(URI) instead */ public Resource makeResource(String aUri) { return createResource(URI.createURI(aUri)); }
/** * Return the CommandStack. */ public BasicCommandStack getCommandStack() { if (commandStack == null) { commandStack = createCommandStack(); commandStack.addCommandStackListener(this); } return commandStack; }
cacheEditModel(editModel, params); EditModelLeastUsedCache.getInstance().access(editModel); editModel.access(accessorKey); if (editModel.isDisposed() || editModel.isDisposing()) { editModel = createEditModelForRead(editModelID, params); cacheEditModel(editModel, params); editModel.access(accessorKey);
public void editModelChanged(EditModelEvent anEvent) { switch (anEvent.getEventCode()) { case EditModelEvent.UNLOADED_RESOURCE : if (anEvent.getChangedResources().contains(resource) && ! resource.isLoaded()) { try { resource.load(resource.getResourceSet().getLoadOptions()); } catch (IOException ioe) { JptCorePlugin.log(ioe); } } break; case EditModelEvent.REMOVED_RESOURCE : if (anEvent.getChangedResources().contains(resource)) { anEvent.getEditModel().removeListener(this); } break; // case EditModelEvent.SAVE : // case EditModelEvent.PRE_DISPOSE : } } // commenting out for now - this *was* a workaround for 202190, but with ArtifactEdit
/** * This only increments the reference count of the children and should only be called if you * know what you are doing. */ public void access(Object accessorKey) { ComposedAccessorKey composedAccessorKey = ComposedAccessorKey.getComposedAccessorKey(accessorKey, this); if (getChildren().size() == 0) { createChildrenIfNecessary(composedAccessorKey); } else { List tempchildren = getChildren(); for (int i = 0; i < tempchildren.size(); i++) { EditModel model = (EditModel) tempchildren.get(i); model.access(composedAccessorKey); } } // removing for defect 1978, children should do all the accessing super.access(accessorKey); }
public EditModel createEditModelForWrite(String editModelID, EMFWorkbenchContext context, Map params) { EditModel editModel = new EditModel(editModelID, context, false); editModel.setAccessAsReadForUnKnownURIs(loadKnownResourcesAsReadOnly); return editModel; }