import org.simantics.databoard.type.UnionType;
import org.simantics.databoard.type.VariantType;
import org.simantics.databoard.util.ObjectUtils;
+import org.simantics.datatypes.literal.GUID;
import org.simantics.db.ChangeSetIdentifier;
import org.simantics.db.Operation;
import org.simantics.db.ReadGraph;
import org.simantics.db.common.request.ObjectsWithType;
import org.simantics.db.common.request.PossibleChild;
import org.simantics.db.common.request.PossibleIndexRoot;
+import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.common.utils.NameUtils;
+import org.simantics.db.event.ChangeListener;
import org.simantics.db.exception.CancelTransactionException;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.ServiceException;
import org.simantics.db.layer0.adapter.GenericRelationIndex;
import org.simantics.db.layer0.adapter.PasteHandler;
import org.simantics.db.layer0.adapter.impl.DefaultPasteHandler;
+import org.simantics.db.layer0.adapter.impl.EntityRemover;
import org.simantics.db.layer0.adapter.impl.TGRemover;
import org.simantics.db.layer0.genericrelation.IndexedRelations;
import org.simantics.db.layer0.internal.SimanticsInternal;
import org.simantics.db.service.ClusteringSupport;
import org.simantics.db.service.CollectionSupport;
import org.simantics.db.service.DebugSupport;
+import org.simantics.db.service.GraphChangeListenerSupport;
import org.simantics.db.service.ManagementSupport;
import org.simantics.db.service.UndoRedoSupport;
import org.simantics.db.service.XSupport;
}
- public static void claimAdaptedValue(WriteGraph graph, Resource objectResource, Object value, Binding binding, Datatype datatype) throws DatabaseException {
+ public static void claimAdaptedValue(WriteGraph graph, Resource objectResource, Object value, Binding binding, Datatype targetDatatype) throws DatabaseException {
try {
- Datatype source = binding.type();
- if(source.equals(datatype)) {
+ Datatype sourceDatatype = binding.type();
+ if(sourceDatatype.equals(targetDatatype)) {
graph.claimValue(objectResource, value, binding);
} else {
- Binding target = Bindings.getBinding(datatype);
- Adapter adapter = Bindings.getAdapter(binding, target);
+ Binding target = Bindings.getBinding(targetDatatype);
+ Adapter adapter = Bindings.getTypeAdapter(binding, target);
graph.claimValue(objectResource, adapter.adapt(value), target);
}
emptyTrashBin(monitor, SimanticsInternal.getSession(), SimanticsInternal.getProject());
}
- public static void emptyTrashBin(final IProgressMonitor monitor, Session session, final Resource project) throws ServiceException {
+ public static void emptyTrashBin(final IProgressMonitor monitor, Session session, final Resource project)
+ throws ServiceException {
final SubMonitor mon = SubMonitor.convert(monitor, "Emptying Trash Bin...", 10000);
try {
+ ArrayList<Resource> unhandled = new ArrayList<Resource>();
session.syncRequest(new DelayedWriteRequest() {
@Override
public void perform(WriteGraph graph) throws DatabaseException {
Layer0X L0X = Layer0X.getInstance(graph);
Resource parent = graph.getSingleObject(project, L0.PartOf);
Resource trashBin = Layer0Utils.getPossibleChild(graph, parent, "TrashBin");
- Collection<Resource> trashes = trashBin != null
- ? graph.getObjects(trashBin, L0.ConsistsOf)
- : Collections.<Resource>emptyList();
+ Collection<Resource> trashes = trashBin != null ? graph.getObjects(trashBin, L0.ConsistsOf)
+ : Collections.<Resource> emptyList();
if (trashes.isEmpty())
throw new CancelTransactionException();
mon.setWorkRemaining((2 + trashes.size()) * 1000);
- for(Resource trash : trashes) {
+ for (Resource trash : trashes) {
if (mon.isCanceled())
throw new CancelTransactionException();
mon.subTask(NameUtils.getSafeName(graph, trash));
+ boolean isIndexRoot = graph.isInstanceOf(trash, L0.IndexRoot);
TGRemover remo = new TGRemover(mon.newChild(1000, SubMonitor.SUPPRESS_ALL_LABELS), trash);
- remo.remove(graph);
- if(graph.isInstanceOf(trash, L0.IndexRoot)) {
- // TODO: this should be an utility
- GenericRelationIndex index = graph.adapt(L0X.DependenciesRelation, GenericRelationIndex.class);
- IndexedRelations ir = graph.getService(IndexedRelations.class);
- // Deletes index files
- ir.reset(null, graph, L0X.DependenciesRelation, trash);
- // Notifies DB listeners
- index.reset(graph, trash);
+ try {
+ remo.remove(graph);
+ unhandled.addAll(remo.getRoots());
+ } catch (DatabaseException e) {
+ // Something went wrong - try to remove this later
+ // with EntityRemover
+ unhandled.add(trash);
+ }
+ if (isIndexRoot) {
+ // TODO: this should be an utility
+ GenericRelationIndex index = graph.adapt(L0X.DependenciesRelation,
+ GenericRelationIndex.class);
+ IndexedRelations ir = graph.getService(IndexedRelations.class);
+ // Deletes index files
+ ir.reset(null, graph, L0X.DependenciesRelation, trash);
+ // Notifies DB listeners
+ index.reset(graph, trash);
}
}
if (mon.isCanceled())
mon.newChild(1000);
}
});
+
+ session.syncRequest(new WriteRequest() {
+ @Override
+ public void perform(WriteGraph graph) throws DatabaseException {
+ for (Resource r : unhandled)
+ EntityRemover.remove(graph, r);
+ }
+ });
+
if (mon.isCanceled())
return;
mon.subTask("Purging Database");
}
return result;
}
+
+ public static Resource getPossiblePredicateByNameFromType(ReadGraph graph, Resource type, String name) throws DatabaseException {
+ Map<String,Resource> domain = getDomainOf(graph, type);
+ return domain.get(name);
+ }
public static Resource getPossiblePredicateByName(ReadGraph graph, Resource instance, String predicateName) throws DatabaseException {
for(Resource type : graph.getPrincipalTypes(instance)) {
}
- public static String prettyPrintResource(ReadGraph graph, Resource resource) throws Exception {
+ public static String prettyPrintResource(ReadGraph graph, Resource resource, boolean ignoreIdentifiers) throws Exception {
TransferableGraphSource source = makeTGSource(graph, resource);
TransferableGraph1 tg = TransferableGraphs.create(graph, source);
GraphRefactoringUtils.fixOntologyExport(tg);
- return PrettyPrintTG.print(tg);
+ System.out.println("Printing resoure " + graph.getURI(resource));
+ return PrettyPrintTG.print(tg, ignoreIdentifiers);
+ }
+
+ /**
+ * Adds a random {@link GUID} as a value for <code>L0.identifier</code>
+ *
+ * @param graph
+ * @param component
+ * for which the identifier is added
+ * @param add
+ * <code>true</code> to invoke addLiteral, <code>false</code> to
+ * invoke claimLiteral
+ * @throws DatabaseException
+ */
+ public static void claimNewIdentifier(WriteGraph graph, Resource component, boolean add) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ GUID guid = GUID.random();
+ if (add)
+ graph.addLiteral(component, L0.identifier, L0.identifier_Inverse, L0.GUID, guid, GUID.BINDING);
+ else
+ graph.claimLiteral(component, L0.identifier, L0.identifier_Inverse, L0.GUID, guid, GUID.BINDING);
+ }
+
+ /**
+ * Sets a new random unique identifier for the specified entity if it already
+ * has an identifier. If the entity does not have a previous identifier, nothing
+ * is done.
+ *
+ * @param graph
+ * @param entity
+ * for which the identifier is added
+ * @return <code>true</code> if the identifier was renewed, <code>false</code>
+ * otherwise
+ * @throws DatabaseException
+ * @see {@link #claimNewIdentifier(WriteGraph, Resource, boolean)}
+ */
+ public static boolean renewIdentifier(WriteGraph graph, Resource entity) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ Statement stm = graph.getPossibleStatement(entity, L0.identifier);
+ if (stm != null) {
+ graph.claimValue(stm.getObject(), GUID.random(), GUID.BINDING);
+ return true;
+ }
+ return false;
+ }
+
+ public static void addMetadataListener(ChangeListener listener) {
+ SimanticsInternal.getSession().getService(GraphChangeListenerSupport.class).addMetadataListener(listener);
+ }
+
+ public static void removeMetadataListener(ChangeListener listener) {
+ SimanticsInternal.getSession().getService(GraphChangeListenerSupport.class).removeMetadataListener(listener);
}
}