/*******************************************************************************
- * Copyright (c) 2007, 2016 Association for Decentralized Information Management in
+ * Copyright (c) 2007, 2017 Association for Decentralized Information Management in
* Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*
* Contributors:
* VTT Technical Research Centre of Finland - initial API and implementation
- * Semantum Oy - JSON plain text input support
+ * Semantum Oy - JSON plain text input support, #7313
*******************************************************************************/
package org.simantics.charts.editor;
import org.eclipse.jface.viewers.ISelection;
import org.simantics.Simantics;
import org.simantics.charts.internal.JsonUtils;
+import org.simantics.charts.internal.VariableUtils;
import org.simantics.charts.query.AddChartItem;
import org.simantics.charts.query.ChartItemDescriptor;
import org.simantics.charts.ui.AddVariableToChartAction;
import org.simantics.db.layer0.variable.RVI;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.VariableReference;
-import org.simantics.db.layer0.variable.Variables;
import org.simantics.g2d.diagram.participant.AbstractDiagramParticipant;
import org.simantics.g2d.dnd.DragItem;
import org.simantics.g2d.dnd.IDnDContext;
VariableReferenceDragItem vrdi = new VariableReferenceDragItem(session.sync(new UnaryRead<RVI, VariableReference>((RVI)data) {
@Override
public VariableReference perform(ReadGraph graph) throws DatabaseException {
- return new VariableReference(parameter, Variables.getDatatype(graph, model, parameter), null);
+ return new VariableReference(parameter, VariableUtils.getDatatype(graph, model, parameter), null);
}
}));
items.add( vrdi );
--- /dev/null
+/*******************************************************************************
+ * Copyright (c) 2017 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ * Semantum Oy - #7313
+ *******************************************************************************/
+package org.simantics.charts.internal;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+import org.simantics.databoard.type.Datatype;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.request.PossibleActiveVariableFromVariable;
+import org.simantics.db.layer0.variable.RVI;
+import org.simantics.db.layer0.variable.Variable;
+import org.simantics.db.layer0.variable.VariableReference;
+import org.simantics.db.layer0.variable.Variables;
+import org.simantics.modeling.utils.VariableReferences;
+
+/**
+ * @author Tuukka Lehtonen
+ * @since 1.28.1, 1.29.0
+ */
+public class VariableUtils {
+
+ public static Datatype getDatatype(ReadGraph graph, Resource resource, RVI rvi) throws DatabaseException {
+ Variable configuration = Variables.getConfigurationContext(graph, resource);
+ Variable active = graph.syncRequest(new PossibleActiveVariableFromVariable(configuration));
+ Variable var = rvi.resolve(graph, active != null ? active : configuration);
+ return var.getDatatype(graph);
+ }
+
+ /**
+ * @param graph
+ * @param targetModel
+ * @param source
+ * @return <code>null</code> if the value is valid JSON but does not contain
+ * a variable reference
+ * @throws DatabaseException
+ * if the value fails to resolve as either JSON or an RVI string
+ */
+ public static List<VariableReference> getVariableReferencesFromString(ReadGraph graph, Resource targetModel, String source) throws DatabaseException {
+ try {
+ // JSON ?
+ Optional<Variable> v = JsonUtils.tryParseJsonPropertyVariable(graph, source);
+ if (v.isPresent())
+ return graph.syncRequest(VariableReferences.variablesToReferences(targetModel, Collections.singletonList(v.get())));
+ // JSON, but no variable info in it.
+ return null;
+ } catch (DatabaseException e) {
+ // RVI as String?
+ RVI rvi = RVI.fromResourceFormat(graph, source);
+ return Collections.singletonList(new VariableReference(rvi, getDatatype(graph, targetModel, rvi), null));
+ }
+ }
+
+}
/*******************************************************************************
- * Copyright (c) 2007, 2014 Association for Decentralized Information Management in
+ * Copyright (c) 2007, 2017 Association for Decentralized Information Management in
* Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*
* Contributors:
* VTT Technical Research Centre of Finland - initial API and implementation
+ * Semantum Oy - #7313
*******************************************************************************/
package org.simantics.charts.ui;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
-import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
import org.eclipse.jface.viewers.ISelection;
import org.simantics.Simantics;
-import org.simantics.charts.internal.JsonUtils;
+import org.simantics.charts.Activator;
+import org.simantics.charts.internal.VariableUtils;
import org.simantics.charts.ontology.ChartResource;
import org.simantics.charts.query.AddChartItem;
import org.simantics.charts.query.ChartItemDescriptor;
@Override
public Runnable create(ReadGraph g, Object target, Object source, int operation) throws DatabaseException {
- //System.out.println("DROP: " + source + " -> " + target);
+ //System.out.println("CHART DROP: " + source + " -> " + target);
final Resource chart = ISelectionUtils.getSinglePossibleKey(target, SelectionHints.KEY_MAIN, Resource.class);
if (chart == null) return null;
if(source instanceof RVI) {
List<VariableReference> refs = Collections.singletonList(new VariableReference((RVI)source,
- SubscriptionDropActionFactory.getDatatype(g, targetModel, (RVI) source), null));
+ VariableUtils.getDatatype(g, targetModel, (RVI) source), null));
return new AddVariableToChartAction(chart, null, refs).init(g);
}
}
if (source instanceof String) {
- // JSON ?
- Optional<Variable> v = JsonUtils.tryParseJsonPropertyVariable(g, (String) source);
- if (v.isPresent()) {
- List<VariableReference> references = toReferences(g, targetModel, Collections.singletonList(v.get()));
- if (!references.isEmpty())
- return new AddVariableToChartAction(chart, null, references).init(g);
- }
+ return handleStringDrop(g, chart, targetModel, (String) source);
}
return null;
}
- private static List<VariableReference> toReferences(ReadGraph graph, Resource contextIndexRoot, List<Variable> variables) throws DatabaseException {
+ private Runnable handleStringDrop(ReadGraph graph, Resource chart, Resource targetModel, String source) {
+ try {
+ List<VariableReference> refs = VariableUtils.getVariableReferencesFromString(graph, targetModel, source);
+ return new AddVariableToChartAction(chart, null, refs).init(graph);
+ } catch (DatabaseException e) {
+ Activator.getDefault().getLog().log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, getClass().getSimpleName() + ": Unrecognized String input: " + source));
+ return null;
+ }
+ }
+
+ private static List<VariableReference> toReferences(ReadGraph graph, Resource contextIndexRoot, List<Variable> variables) throws DatabaseException {
if (variables.isEmpty())
return Collections.emptyList();
return filterReferences( graph.syncRequest(VariableReferences.variablesToReferences(contextIndexRoot, variables)) );
/*******************************************************************************
- * Copyright (c) 2014 Association for Decentralized Information Management in
+ * Copyright (c) 2014, 2017 Association for Decentralized Information Management in
* Industry THTH ry.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
*
* Contributors:
* VTT Technical Research Centre of Finland - initial API and implementation
+ * Semantum Oy - #7313
*******************************************************************************/
package org.simantics.charts.ui;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
-import java.util.Optional;
import java.util.Set;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
import org.simantics.Simantics;
import org.simantics.browsing.ui.common.ErrorLogger;
-import org.simantics.charts.internal.JsonUtils;
-import org.simantics.databoard.type.Datatype;
+import org.simantics.charts.Activator;
+import org.simantics.charts.internal.VariableUtils;
import org.simantics.databoard.util.ObjectUtils;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.SelectionHints;
import org.simantics.db.layer0.adapter.DropActionFactory;
-import org.simantics.db.layer0.request.PossibleActiveVariableFromVariable;
import org.simantics.db.layer0.request.PossibleModel;
import org.simantics.db.layer0.variable.RVI;
-import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.VariableReference;
-import org.simantics.db.layer0.variable.Variables;
import org.simantics.layer0.Layer0;
import org.simantics.modeling.ModelingResources;
import org.simantics.modeling.PropertyVariables;
@Override
public Runnable create(ReadGraph g, Object target, Object source, int operation) throws DatabaseException {
- //System.out.println("DROP: " + source + " -> " + target);
+ //System.out.println("SUBSCRIPTION DROP: " + source + " -> " + target);
final Resource subscription = ISelectionUtils.getSinglePossibleKey(target, SelectionHints.KEY_MAIN, Resource.class);
if (subscription == null)
if(source instanceof RVI) {
RVI rvi = (RVI)source;
- List<VariableReference> refs = Collections.singletonList(new VariableReference(rvi, getDatatype(g, targetModel, rvi), null));
+ List<VariableReference> refs = Collections.singletonList(new VariableReference(rvi, VariableUtils.getDatatype(g, targetModel, rvi), null));
return addSubscriptions(g, subscription, refs, Collections.<Resource>emptySet());
}
}
if (source instanceof String) {
- // JSON ?
- Optional<Variable> v = JsonUtils.tryParseJsonPropertyVariable(g, (String) source);
- if (v.isPresent()) {
- List<VariableReference> references = g.syncRequest(VariableReferences.variablesToReferences(targetModel, Collections.singletonList(v.get())));
- return addSubscriptions(g, subscription, references, Collections.emptySet());
- }
+ return handleStringDrop(g, subscription, targetModel, (String) source);
}
return null;
}
- private Runnable addSubscriptions(ReadGraph graph, Resource subscription, List<VariableReference> references,
+ private Runnable handleStringDrop(ReadGraph graph, Resource subscription, Resource targetModel, String source) throws DatabaseException {
+ try {
+ List<VariableReference> refs = VariableUtils.getVariableReferencesFromString(graph, targetModel, source);
+ return addSubscriptions(graph, subscription, refs, Collections.emptySet());
+ } catch (DatabaseException e) {
+ Activator.getDefault().getLog().log(new Status(IStatus.WARNING, Activator.PLUGIN_ID, getClass().getSimpleName() + ": Unrecognized String input: " + source));
+ return null;
+ }
+ }
+
+ private Runnable addSubscriptions(ReadGraph graph, Resource subscription, List<VariableReference> references,
Set<Resource> movedSubscriptionItems) throws DatabaseException {
AddVariableToChartAction action = new AddVariableToChartAction(null, subscription, references).init(graph);
return () -> {
};
}
- static Datatype getDatatype(ReadGraph graph, Resource resource, RVI rvi) throws DatabaseException {
- Variable configuration = Variables.getConfigurationContext(graph, resource);
- Variable active = graph.syncRequest(new PossibleActiveVariableFromVariable(configuration));
- Variable var = rvi.resolve(graph, active != null ? active : configuration);
- return var.getDatatype(graph);
- }
-
}
@sclAttribute PROPERTIES.commands "commandList self"
COMPONENTS.PrimitiveComponent <T COMPONENTS.Component
+ @L0.assert PROPERTIES.primitiveProperties
+ _ : L0.Value
+ L0.domainProperties FUNCTIONS.primitiveProperties
+
COMPONENTS.ParentlessComponent <T COMPONENTS.PrimitiveComponent /* Component without a parent, e.g. Root, DialogBox */
FUNCTIONS.pathExists : L0.Function
L0.HasValueType "Boolean"
+
+FUNCTIONS.primitiveProperties : L0.ExternalValue
+ L0.HasValueType "VariableMap"
+
\ No newline at end of file
PROPERTIES.model <R L0.HasProperty : L0.FunctionalRelation
==> "Variable"
-
+
+PROPERTIES.primitiveProperties <R L0.HasProperty : L0.FunctionalRelation
+ ==> "String"
+
PROPERTIES.exists
@defAttribute L0.Boolean
L0.RequiresValueType "Boolean"
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.List;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import org.simantics.db.layer0.variable.Variables;
import org.simantics.document.base.ontology.DocumentationResource;
import org.simantics.document.server.Functions.RootVariable;
+import org.simantics.document.server.request.NodeRequest;
+import org.simantics.document.server.request.NodeRequestUtils;
import org.simantics.structural2.variables.Connection;
import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
import org.simantics.utils.datastructures.Pair;
SortedMap<String, Variable> childMap = new TreeMap<String, Variable>(AlphanumComparator.COMPARATOR);
- for(Variable property : variable.getProperties(graph)) {
- Collection<String> classifications = property.getPossiblePropertyValue(graph, Variables.CLASSIFICATIONS);
- if(classifications != null) {
- if(classifications.contains(DocumentationResource.URIs.Document_ChildRelation)) {
- Resource cp = property.getPossiblePredicateResource(graph);
- String i = graph.getRelatedValue(cp, DOC.Document_ChildRelation_ordinal, Bindings.STRING);
-
- Connection conn = property.getValue(graph);
- Variable childConnectionPoint = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, property, conn);
- if(childConnectionPoint != null) {
- childMap.put(i, childConnectionPoint.getParent(graph));
- }
- } else if (DOC.Relations_partN.equals(property.getPossiblePredicateResource(graph))) {
- Connection conn = property.getValue(graph);
-
- for (Variable childConnectionPoint : DocumentServerUtils.getOtherConnectionPoints(graph, property, conn)) {
- Variable child = childConnectionPoint.getParent(graph);
- String i = findManualOrdinal(graph, child);
- if (i == null) {
- i = "0";
- }
- childMap.put(i, child);
- }
+ for(Variable property : variable.getProperties(graph, DocumentationResource.URIs.Document_ChildRelation)) {
+ Resource cp = property.getPossiblePredicateResource(graph);
+ String i = graph.getRelatedValue(cp, DOC.Document_ChildRelation_ordinal, Bindings.STRING);
+ Connection conn = property.getValue(graph);
+ Variable childConnectionPoint = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, property, conn);
+ if(childConnectionPoint != null) {
+ childMap.put(i, childConnectionPoint.getParent(graph));
+ }
+ }
+
+ Variable property = variable.getPossibleProperty(graph, "partN");
+ if(property != null) {
+ Connection conn = property.getValue(graph);
+ for (Variable childConnectionPoint : DocumentServerUtils.getOtherConnectionPoints(graph, property, conn)) {
+ Variable child = childConnectionPoint.getParent(graph);
+ String i = findManualOrdinal(graph, child);
+ if (i == null) {
+ i = "0";
}
+ childMap.put(i, child);
}
}
+
return childMap.values();
}
return null;
}
+
+ public static Variable getPossibleChildConnectionPoint(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
+
+ Collection<VariableConnectionPointDescriptor> descs = conn.getConnectionPointDescriptors(graph, null);
+ if(descs.size() != 2) return null;
+
+ DocumentationResource DOC = DocumentationResource.getInstance(graph);
+
+ for(VariableConnectionPointDescriptor desc : descs) {
+ Resource res = desc.getConnectionPointResource(graph);
+ if(graph.isInstanceOf(res, DOC.Relations_parentRelation)) continue;
+ //if(desc.isFlattenedFrom(graph, connectionPoint)) continue;
+ return desc.getVariable(graph);
+ }
+
+ return null;
+
+ }
public static Collection<Variable> getOtherConnectionPoints(ReadGraph graph, Variable connectionPoint, Connection conn) throws DatabaseException {
}
- public static class DocumentValue extends VariableRead<Object> {
-
- public DocumentValue(Variable variable) {
- super(variable);
- }
-
- @Override
- public Object perform(ReadGraph graph) throws DatabaseException {
- return variable.getValue(graph);
- }
-
- @Override
- public String toString() {
- return "DocumentValue[" + variable + "]";
- }
-
- }
-
public static Object getValue(ReadGraph graph, Variable attrib) throws DatabaseException {
return graph.syncRequest(new DocumentValue(attrib));
}
return variable.getProperties(graph, DOC.Document_AttributeRelation);
}
- static class AttributesRequest extends VariableRead<Pair<Collection<Variable>, Collection<Variable>>> {
+ public static class AttributesRequest extends VariableRead<Pair<JSONObject, Collection<Variable>>> {
public AttributesRequest(Variable variable) {
super(variable);
}
@Override
- public Pair<Collection<Variable>,Collection<Variable>> perform(ReadGraph graph) throws DatabaseException {
+ public Pair<JSONObject,Collection<Variable>> perform(ReadGraph graph) throws DatabaseException {
ArrayList<Variable> statics = new ArrayList<Variable>();
- ArrayList<Variable> dynamics = new ArrayList<Variable>();
DocumentationResource DOC = DocumentationResource.getInstance(graph);
- for(Variable property : getAttributes(graph, DOC, variable)) {
- Boolean defaultProperty = property.getPossiblePropertyValue(graph, "default");
- if(defaultProperty != null && defaultProperty) {
-// System.err.println("" + property.getURI(graph) + " is default");
- continue;
- }
-// else {
-// System.err.println("" + property.getURI(graph) + " is not default");
-// }
- Boolean dynamicProperty = property.getPossiblePropertyValue(graph, DOC.Document_AttributeRelation_dynamic);
- if(dynamicProperty != null && dynamicProperty) dynamics.add(property);
- else statics.add(property);
+
+ Variable primitives = variable.getProperty(graph, DOC.Properties_primitiveProperties);
+ for(Variable property : primitives.getProperties(graph)) {
+ statics.add(property);
+ // NO SUPPORT FOR DYNAMICS AT THIS STAGE
}
- return new Pair<Collection<Variable>, Collection<Variable>>(statics, dynamics);
+
+ JSONObject staticContent = computeStatic(graph, variable, statics);
+
+ return new Pair<JSONObject, Collection<Variable>>(staticContent, Collections.emptyList());
+
+ }
+
+ JSONObject computeStatic(ReadGraph graph, Variable variable, ArrayList<Variable> statics) throws DatabaseException {
+
+ JSONObject base = graph.syncRequest(new org.simantics.document.server.request.DefaultFields(variable));
+ JSONObject object = base.clone();
+
+ for(Variable attrib : statics) {
+ String name = attrib.getName(graph);
+ try {
+ Object value = DocumentServerUtils.getValue(graph, attrib);
+ object.addJSONField(name, value);
+ } catch (Throwable t) {
+ List<String> errorList = object.getJSONField(NodeRequest.ERRORS);
+ if(errorList == null)
+ errorList = new ArrayList<String>();
+
+ String errorMessage = NodeRequestUtils.formatErrorMessage(name, t);
+
+ errorList.add(errorMessage);
+ object.addJSONField(NodeRequest.ERRORS, errorList);
+ }
+
+ }
+
+ return object;
+
}
}
-
- public static Collection<Variable> getStaticAttributes(ReadGraph graph, DocumentationResource DOC, Variable variable) throws DatabaseException {
- Pair<Collection<Variable>, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
- return attribs.first;
- }
public static Collection<Variable> getDynamicAttributes(ReadGraph graph, final DocumentationResource DOC, Variable variable) throws DatabaseException {
- Pair<Collection<Variable>, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
+ Pair<JSONObject, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
return attribs.second;
}
--- /dev/null
+package org.simantics.document.server;
+
+import org.simantics.db.ReadGraph;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.request.VariableRead;
+import org.simantics.db.layer0.variable.Variable;
+import org.simantics.document.server.request.DocumentRequest;
+
+public class DocumentValue extends VariableRead<Object> {
+
+ public DocumentValue(Variable variable) {
+ super(variable);
+ }
+
+ @Override
+ public Object perform(ReadGraph graph) throws DatabaseException {
+ if(DocumentRequest.PROFILE) return performProfiled(graph);
+ return variable.getValue(graph);
+ }
+
+ public Object performProfiled(ReadGraph graph) throws DatabaseException {
+ long start = System.nanoTime();
+ Object result = variable.getValue(graph);
+ //System.err.println("DocumentValue " + result + " " + variable.getURI(graph));
+ long dura = System.nanoTime()-start;
+ if(dura > DocumentRequest.PROFILE_THRESHOLD_VALUEREQUEST * 1e3) {
+ System.err.println("DocumentValue " + System.identityHashCode(this) + " in " + 1e-6*dura + "ms. "+ variable.getURI(graph));
+ }
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "DocumentValue[" + variable + "]";
+ }
+
+}
\ No newline at end of file
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import org.simantics.databoard.Datatypes;
import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.type.Datatype;
+import org.simantics.db.AsyncReadGraph;
+import org.simantics.db.DirectStatements;
import org.simantics.db.ReadGraph;
import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
import org.simantics.db.Session;
+import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.primitiverequest.Adapter;
import org.simantics.db.common.procedure.adapter.TransientCacheListener;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.function.All;
import org.simantics.db.layer0.request.ProjectModels;
+import org.simantics.db.layer0.request.PropertyInfo;
+import org.simantics.db.layer0.request.PropertyInfoRequest;
import org.simantics.db.layer0.request.VariableProperty;
import org.simantics.db.layer0.request.VariableRead;
import org.simantics.db.layer0.request.VariableValueWithBinding;
import org.simantics.db.layer0.variable.ProxyChildVariable;
import org.simantics.db.layer0.variable.ProxySessionRequest;
import org.simantics.db.layer0.variable.ProxyVariables;
+import org.simantics.db.layer0.variable.StandardAssertedGraphPropertyVariable;
import org.simantics.db.layer0.variable.StandardGraphChildVariable;
+import org.simantics.db.layer0.variable.StandardGraphPropertyVariable;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.layer0.variable.VariableMap;
import org.simantics.db.layer0.variable.VariableMapImpl;
import org.simantics.db.layer0.variable.Variables;
+import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.service.DirectQuerySupport;
import org.simantics.document.base.ontology.DocumentationResource;
import org.simantics.document.server.bean.Command;
import org.simantics.document.server.bean.DataDefinition;
import org.simantics.simulation.ontology.SimulationResource;
import org.simantics.simulation.project.IExperimentManager;
import org.simantics.structural2.variables.Connection;
+import org.simantics.structural2.variables.StandardProceduralChildVariable;
import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
import gnu.trove.map.hash.THashMap;
public class Functions {
+
+ private static class PrimitivePropertyStatementsProcedure implements AsyncProcedure<DirectStatements> {
+
+ public DirectStatements result;
+
+ @Override
+ public void execute(AsyncReadGraph graph, DirectStatements result) {
+ this.result = result;
+ }
+
+ @Override
+ public void exception(AsyncReadGraph graph, Throwable throwable) {
+ }
+
+ }
+
+ @SCLValue(type = "VariableMap")
+ public static VariableMap primitiveProperties = new VariableMapImpl() {
+
+ @Override
+ public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
+ return All.getStandardPropertyDomainPropertyVariableFromValue(graph, context, name);
+ }
+
+ @Override
+ public Map<String, Variable> getVariables(final ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
+
+ Variable parent = context.getParent(graph);
+
+ DocumentationResource DOC = DocumentationResource.getInstance(graph);
+
+ if(parent instanceof StandardProceduralChildVariable) {
+
+ StandardProceduralChildVariable procedural = (StandardProceduralChildVariable)parent;
+ for(Variable property : procedural.getProperties(graph/*, DocumentationResource.URIs.Document_AttributeRelation*/)) {
+ if(property instanceof StandardAssertedGraphPropertyVariable) {
+ StandardAssertedGraphPropertyVariable ass = (StandardAssertedGraphPropertyVariable)property;
+ if("datadefinitions".equals(ass.property.name) || "commands".equals(ass.property.name)) {
+ Object value = property.getPossibleValue(graph);
+ if(value != null) map.put(ass.property.name, new ConstantPropertyVariable(parent, ass.property.name, value, null));
+ }
+ continue;
+ }
+ Resource predicate = property.getPossiblePredicateResource(graph);
+ if(predicate != null) {
+ PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
+ if(info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
+ Variable prop = parent.getProperty(graph, predicate);
+ Object value = prop.getValue(graph);
+ if(map == null) map = new HashMap<String,Variable>();
+ map.put(info.name, new ConstantPropertyVariable(parent, info.name, value, null));
+ }
+ }
+ }
+
+ } else {
+
+ DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
+ PrimitivePropertyStatementsProcedure foo = new PrimitivePropertyStatementsProcedure();
+
+ dqs.forEachDirectPersistentStatement(graph, parent.getRepresents(graph), foo);
+ for(Statement stm : foo.result) {
+ Resource predicate = stm.getPredicate();
+ PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
+ if(info.isHasProperty && info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
+ if(map == null) map = new HashMap<String,Variable>();
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, predicate);
+ Object value = prop.getValue(graph);
+ map.put(info.name, new ConstantPropertyVariable(parent, info.name, value, null));
+ }
+ }
+
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_dataDefinitions);
+ Object value = prop.getPossibleValue(graph);
+ if(value != null) map.put("dataDefinitions", new ConstantPropertyVariable(parent, "dataDefinitions", value, null));
+ prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_commands);
+ value = prop.getPossibleValue(graph);
+ if(value != null) map.put("commands", new ConstantPropertyVariable(parent, "commands", value, null));
+
+ }
+
+ if(map == null) return Collections.emptyMap();
+
+ return map;
+
+ }
+
+ };
+
@SCLValue(type = "VariableMap")
public static VariableMap inputSpaceChildren = new VariableMapImpl() {
Variable root = Variables.getRootVariable(graph);
return new DocumentProxyChildVariable(context, context, root, ProxyChildVariable.CONTEXT_BEGIN);
}
-
+
@Override
public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
if(ProxyChildVariable.CONTEXT_BEGIN.equals(name)) return getProxy(graph, context);
return All.standardChildDomainChildren.getVariable(graph, context, name);
-
+
}
@Override
if(map == null) map = new THashMap<String,Variable>();
map.put(ProxyChildVariable.CONTEXT_BEGIN, getProxy(graph, context));
return map;
-
+
}
-
+
};
-
+
static class DocumentProxyChildVariable extends ProxyChildVariable {
public DocumentProxyChildVariable(Variable base, Variable parent, Variable other, String name) {
super(base, parent, other, name);
}
-
+
@Override
public Variable create(Variable base, Variable parent, Variable other, String name) {
return new DocumentProxyChildVariable(base, parent, other, name);
}
-
+
public Variable getPossibleChild(ReadGraph graph, String name) throws DatabaseException {
-
+
if(CONTEXT_END.equals(name)) {
if(other instanceof ProxyChildVariable) {
// The context is also a proxy - let it do the job
return new RootVariable(this, base.getRepresents(graph));
}
}
-
+
return super.getPossibleChild(graph, name);
-
+
}
-
+
public Collection<Variable> getChildren(ReadGraph graph) throws DatabaseException {
Collection<Variable> result = super.getChildren(graph);
result.add(new RootVariable(this, base.getRepresents(graph)));
}
return result;
-
- }
-
+
+ }
+
}
-
+
static class RootVariable extends StandardGraphChildVariable {
public RootVariable(DocumentProxyChildVariable parent, Resource resource) {
super(parent, null, resource);
}
-
+
@Override
public String getName(ReadGraph graph) throws DatabaseException {
return ProxyChildVariable.CONTEXT_END;
}
-
+
@SuppressWarnings("deprecation")
@Override
public Variable getNameVariable(ReadGraph graph) throws DatabaseException {
return new ConstantPropertyVariable(this, Variables.NAME, ProxyChildVariable.CONTEXT_END, Bindings.STRING);
}
-
+
}
@SCLValue(type = "ReadGraph -> Resource -> Variable -> Variable")
}
return Variables.getVariable(graph, uri);
}
-
+
public static Variable stateVariable(ReadGraph graph, Variable self) throws DatabaseException {
Variable session = graph.syncRequest(new ProxySessionRequest(self));
if (session == null)
throw new DatabaseException("No state for " + self.getURI(graph));
return session.getPossibleChild(graph, "__scl__");
}
-
+
@SCLValue(type = "ReadGraph -> Resource -> Variable -> Variable")
public static Variable state(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
Variable session = graph.syncRequest(new ProxySessionRequest(context));
public static Variable session(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
return graph.syncRequest(new ProxySessionRequest(context));
}
-
+
@SCLValue(type = "ReadGraph -> Resource -> Variable -> Variable")
public static Variable experiment(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
// Try if experiment (run) has been used as the input
while(var != null && !graph.isInstanceOf(var.getRepresents(graph), SR.Run)) {
var = var.getParent(graph);
}
-
+
if(var != null) {
IExperiment exp = getExperiment(graph, var);
if(exp == null)
return null;
}
-
+
return var;
}
-
+
@SCLValue(type = "ReadGraph -> Resource -> Variable -> Variable")
public static Variable model(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
Variable var = input(graph, converter, context);
while(var != null && !graph.isInstanceOf(var.getRepresents(graph), MOD.StructuralModel)) {
var = var.getParent(graph);
}
-
+
return var;
}
-
+
private static Collection<Variable> getBroadcasted(ReadGraph graph, Variable target) throws DatabaseException {
-
+
ArrayList<Variable> result = new ArrayList<Variable>();
-
+
DocumentationResource DOC = DocumentationResource.getInstance(graph);
Variable broadcasted = target.getPossibleProperty(graph, DOC.Relations_broadcasted);
if(broadcasted != null) result.add(broadcasted);
-
+
for(Variable child : DocumentServerUtils.getChildrenInOrdinalOrder(graph, target)) {
result.addAll(getBroadcasted(graph, child));
}
-
+
return result;
-
+
}
private static List<Command> getCommands(ReadGraph graph, Collection<Variable> commandVariables, String trigger, CommandContext constants, boolean broadcast) throws DatabaseException {
-
+
if(commandVariables.isEmpty()) return Collections.emptyList();
-
+
String t = trigger;
TreeMap<Integer, List<Command>> sequences = new TreeMap<Integer, List<Command>>();
-
+
DocumentationResource DOC = DocumentationResource.getInstance(graph);
-
+
int count = 0;
for (Variable c : commandVariables) {
-
+
if(trigger == null)
t = c.getName(graph);
-
+
Connection conn = c.getValue(graph);
Variable targetConnectionPoint = DocumentServerUtils.getPossibleCommandTriggerConnectionPoint(graph, c, conn);
if (targetConnectionPoint != null) {
Variable target = targetConnectionPoint.getParent(graph);
if (target != null) {
-
+
Boolean enabled = target.getPossiblePropertyValue(graph, DOC.Properties_exists, Bindings.BOOLEAN);
if(enabled != null && !enabled) continue;
-
+
Integer ordinal;
if (broadcast) {
ordinal = ++count;
ordinal = Integer.parseInt(o);
} catch (NumberFormatException e) {}
}
-
+
String constantKey = target.getPossiblePropertyValue(graph, "constantKey");
String constantValue = target.getPossiblePropertyValue(graph, "constantValue");
-
+
CommandContextMutable newConstants = (CommandContextMutable)constants;
if(constantKey != null && constantValue != null) {
if(!constantKey.isEmpty()) {
newConstants.putString(constantKey, constantValue);
}
}
-
+
String requiredKey = target.getPossiblePropertyValue(graph, "requiredKey");
if(requiredKey != null && !requiredKey.isEmpty()) {
if (newConstants == constants) {
}
newConstants.putRow(CommandContext.REQUIRED_KEYS, Collections.<Object>singletonList(requiredKey));
}
-
+
String forbiddenKey = target.getPossiblePropertyValue(graph, "forbiddenKey");
if(forbiddenKey != null && !forbiddenKey.isEmpty()) {
if (newConstants == constants) {
Command command = new Command(DocumentServerUtils.getId(graph, target), t,
targetConnectionPoint.getName(graph), newConstants);
sequences.put(ordinal, Collections.singletonList(command));
-
+
}
}
commands.add(command);
}
}
-
+
return commands;
}
dataDefinitions.add(new DataDefinition(DocumentServerUtils.getId(graph, data),
sourceProperty, targetProperty));
-
+
} else if (graph.isInheritedFrom(type, DOC.Components_DefVars)) {
List<String> sourcesProperty = toList(dataDefinition.getPropertyValue(graph, DOC.Properties_sources), String.class);
return Collections.<T>emptyList();
}
}
-
+
public static AbstractEventHandler emptyOnClick(ReadGraph graph) throws DatabaseException {
return new EventHandler() {
-
@Override
public ServerResponse handle(ReadGraph graph, CommandContext parameters) throws DatabaseException {
return null;
}
-
};
}
-
+
public static AbstractEventHandler writeEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
-
+
final Session session = graph.getSession();
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
String result = session.sync(new WriteResultRequest<String>() {
-
+
@Override
public String perform(WriteGraph graph) throws DatabaseException {
SCLContext sclContext = SCLContext.getCurrent();
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
return null;
-
+
}
-
+
});
-
+
return new SuccessResponse(result);
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
-
+
public static AbstractEventHandler readEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
-
+
final Session session = graph.getSession();
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
String result = session.sync(new UniqueRead<String>() {
-
+
@Override
public String perform(ReadGraph graph) throws DatabaseException {
SCLContext sclContext = SCLContext.getCurrent();
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
return null;
-
+
}
-
+
});
-
+
return new SuccessResponse(result);
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
public static AbstractEventHandler readEventHandler2(ReadGraph graph, final Function fn) {
-
+
final Session session = graph.getSession();
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
CommandResult result = session.sync(new UniqueRead<CommandResult>() {
-
+
@Override
public CommandResult perform(ReadGraph graph) throws DatabaseException {
SCLContext sclContext = SCLContext.getCurrent();
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
return null;
-
+
}
-
+
});
-
+
return result;
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
if(anyFunction == null) return null;
final List<TCon> effects = ServerSCLHandlerValueRequest.getEffects(graph, anyFunction);
-
+
final Function1<CommandContext, CommandResult> fn = anyFunction.getValue(graph);
String expression = anyFunction.getPropertyValue(graph, "expression");
-
+
final Session session = graph.getSession();
-
+
return new AbstractResponseHandler(expression) {
-
+
private String formatError(RequestProcessor proc, Throwable t) {
-
+
try {
-
+
return proc.syncRequest(new UniqueRead<String>() {
@Override
message.append(" handler=" + path + "\n");
message.append(" expression=" + expr + "\n");
message.append(" message=" + t.getMessage() + "\n");
-
+
StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw));
message.append(" stack trace=" + sw);
-
+
return message.toString();
}
-
+
});
-
+
} catch (DatabaseException e) {
-
+
return e.getMessage();
-
+
}
-
+
}
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
IConsole console = parameters.getValue("__console__");
SCLReportingHandler printer = (console != null) ? new ConsoleSCLReportingHandler(console)
: (SCLReportingHandler) SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
Object result = null;
if(effects.contains(Types.WRITE_GRAPH)) {
}
});
-
+
} else if(effects.contains(Types.READ_GRAPH)) {
result = session.sync(new UniqueRead<Object>() {
@Override
public Object perform(ReadGraph graph) throws DatabaseException {
-
+
SCLContext sclContext = SCLContext.getCurrent();
Object oldGraph = sclContext.put("graph", graph);
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
-
+
try {
Object response = fn.apply(parameters);
return response;
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
}
});
} else {
-
+
SCLContext sclContext = SCLContext.getCurrent();
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
if (result instanceof org.simantics.document.server.serverResponse.Error) {
return (CommandResult)result;
}
-
+
if (result instanceof CommandResult) {
return (CommandResult)result;
} else {
CommandContextMutable assignments = new CommandContextImpl();
assignments.putValue("result", result);
return new ServerResponse(200, "", assignments);
- }
-
+ }
+
} catch (Throwable e) {
return new org.simantics.document.server.serverResponse.Error(formatError(Simantics.getSession(), e));
}
-
+
}
-
+
};
}
-
+
public static AbstractEventHandler writeEventHandler2(ReadGraph graph, final Function fn) {
-
+
final Session session = graph.getSession();
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
CommandResult result = session.syncRequest(new WriteResultRequest<CommandResult>() {
-
+
@Override
public CommandResult perform(WriteGraph graph) throws DatabaseException {
SCLContext sclContext = SCLContext.getCurrent();
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
return null;
-
+
}
-
+
});
-
+
return result;
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
public static AbstractEventHandler eventHandler2(ReadGraph graph, final Function fn) {
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
-
+
SCLContext sclContext = SCLContext.getCurrent();
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
}
return null;
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
public static AbstractEventHandler eventHandler(ReadGraph graph, final Function fn) {
-
+
return new AbstractEventHandler() {
-
+
@Override
public CommandResult handle(final CommandContext parameters) {
-
+
final SCLReportingHandler printer = (SCLReportingHandler)SCLContext.getCurrent().get(SCLReportingHandler.REPORTING_HANDLER);
-
+
try {
String result = "";
-
+
SCLContext sclContext = SCLContext.getCurrent();
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
} finally {
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
-
+
return new SuccessResponse(result);
-
+
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
}
-
+
}
-
+
};
}
return null;
}
-
+
public static CommandContextMutable putTuple(CommandContextMutable context, String key, Object tuple) {
List<Object> list = new ArrayList<Object>();
if (tuple instanceof Tuple) {
Collections.addAll(list, ((Tuple)tuple).toArray());
} else {
- list.add(tuple);
+ list.add(tuple);
}
context.putRow(key, list);
return context;
}
-
+
public static List<Object> getTuples(CommandContext context, String key) {
List<List<Object>> rows = context.getRows(key);
List<Object> tuples = new ArrayList<Object>();
}
return tuples;
}
-
+
public static String printContext(CommandContext context) {
return context.toString();
}
-
+
@SCLValue(type = "AbstractEventHandler")
public static AbstractEventHandler emptyEvent = new AbstractEventHandler() {
};
public static String sclStateKey(ReadGraph graph, Variable base, Variable self, String ref) throws DatabaseException {
-
+
String baseURI = base.getURI(graph);
-
+
String selfURI = self.getURI(graph);
-
+
String prefix = selfURI.substring(0, selfURI.indexOf(ProxyChildVariable.CONTEXT_BEGIN));
String suffix = selfURI.substring(selfURI.lastIndexOf(ProxyChildVariable.CONTEXT_END) + ProxyChildVariable.CONTEXT_END.length());
String stripped = prefix + suffix;
-
+
String relative = Variables.getRelativeRVI(baseURI, stripped);
-
+
return Variables.getRVI(relative, ref);
-
+
}
-
+
public static Variable sclStateVariable(ReadGraph graph, Variable base, Variable self, String ref) throws DatabaseException {
-
+
String id = sclStateKey(graph, base, self, ref);
Variable sclVar = base.getPossibleChild(graph, "__scl__");
if(sclVar == null) return null;
-
+
return sclVar.getPossibleProperty(graph, id);
-
+
}
-
+
public static Object sclStateValueOrDefault(ReadGraph graph, Variable base, Variable self, String ref, Object defaultValue) throws DatabaseException {
-
+
Variable stateVariable = sclStateVariable(graph, base, self, ref);
if (stateVariable != null) {
-
+
return stateVariable.getValue(graph);
-
+
} else {
-
+
String id = sclStateKey(graph, base, self, ref);
SCLRealm realm = SCLSessionManager.getOrCreateSCLRealm(base.getURI(graph) + "/__scl__");
realm.getConnection().setVariable(id, getSCLType(defaultValue), defaultValue);
-
+
return defaultValue;
-
+
}
}
-
+
public static void setSclStateValue(WriteGraph graph, Variable base, Variable self, String ref, Object value) throws DatabaseException {
-
+
String id = sclStateKey(graph, base, self, ref);
SCLRealm realm = SCLSessionManager.getOrCreateSCLRealm(base.getURI(graph)+"/__scl__");
realm.getConnection().setVariable(id, getSCLType(value), value);
realm.refreshVariablesSync();
-
+
}
-
+
public static Object projectComponentState(ReadGraph graph, Variable self, String ref, Object defaultValue) throws DatabaseException {
Resource project = Simantics.getProjectResource();
Variable component = self.getParent(graph);
Variable projectVariable = Variables.getVariable(graph, project);
return sclStateValueOrDefault(graph, projectVariable, component, ref, defaultValue);
}
-
+
public static void setProjectComponentState(WriteGraph graph, Variable self, String ref, Object value) throws DatabaseException {
Resource project = Simantics.getProjectResource();
Variable component = self.getParent(graph);
Variable projectVariable = Variables.getVariable(graph, project);
setSclStateValue(graph, projectVariable, component, ref, value);
}
-
+
private static Type getSCLType(Object value) throws DatabaseException {
Binding b = Bindings.getBindingUnchecked(value.getClass());
Datatype t = b.type();
public static String documentModelContributionLabel(ReadGraph graph, Variable var) throws DatabaseException {
return var.getName(graph);
}
-
+
public static Object getPropertyValueCached(ReadGraph graph, Variable variable, String name, Binding binding) throws DatabaseException {
Variable property = graph.syncRequest(new VariableProperty(variable, name));
return graph.syncRequest(new VariableValueWithBinding<Object>(property, binding));
return graph.syncRequest(new ParentExistsRequest(variable.getParent(graph)));
}
-
+
}
public static class PathExistsRequest extends VariableRead<Boolean> {
@Override
public Boolean perform(ReadGraph graph) throws DatabaseException {
-
+
Variable widget = variable.getParent(graph);
-
+
Boolean exists = widget.getPossiblePropertyValue(graph, "exists");
if (exists == null || !exists) return false;
-
+
if (!graph.syncRequest(new ParentExistsRequest(widget.getParent(graph)))) return false;
-
+
DocumentationResource DOC = DocumentationResource.getInstance(graph);
- Collection <Variable> cps = widget.getProperties(graph, DOC.Relations_parentRelation);
+ Collection <Variable> cps = widget.getProperties(graph, DocumentationResource.URIs.Relations_parentRelation);
for (Variable cp : cps) {
-
+
Connection conn = cp.getValue(graph);
- Variable otherCp = DocumentServerUtils.getPossibleOtherConnectionPoint(graph, cp, conn);
+ Variable otherCp = DocumentServerUtils.getPossibleChildConnectionPoint(graph, cp, conn);
if (otherCp != null) {
Variable parentWidget = otherCp.getParent(graph);
if (parentWidget.<Boolean>getPropertyValue(graph, "pathExists")) {
}
}
}
-
+
Resource type = widget.getType(graph);
return graph.isInheritedFrom(type, DOC.Components_ParentlessComponent) ||
(graph.isInheritedFrom(type, DOC.DocumentComponent) && cps.isEmpty());
}
- }
-
+ }
+
@SCLValue(type = "ReadGraph -> Resource -> Variable -> Boolean")
public static boolean pathExists(ReadGraph graph, Resource converter, Variable context) throws DatabaseException {
return graph.syncRequest(new PathExistsRequest(context));
}
-
-
+
}
\ No newline at end of file
import org.simantics.db.layer0.request.VariableRead;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.db.service.CollectionSupport;
-import org.simantics.document.base.ontology.DocumentationResource;
import org.simantics.structural2.scl.StructuralComponent;
public class VariableStructuralContext extends StructuralComponent<Variable> {
final private Variable selfVariable;
final private Variable variable;
- final private DocumentationResource DOC;
public VariableStructuralContext(ReadGraph graph, Variable selfVariable) throws DatabaseException {
this.selfVariable = selfVariable;
this.variable = selfVariable.getParent(graph).getParent(graph);
- this.DOC = DocumentationResource.getInstance(graph);
}
@Override
package org.simantics.document.server.bean;
-import org.simantics.databoard.util.Bean;
import org.simantics.document.server.io.CommandContext;
import org.simantics.document.server.io.ICommand;
--- /dev/null
+package org.simantics.document.server.request;
+
+import org.simantics.databoard.Bindings;
+import org.simantics.databoard.Databoard;
+import org.simantics.databoard.binding.Binding;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.request.VariableRead;
+import org.simantics.db.layer0.variable.Variable;
+import org.simantics.document.base.ontology.DocumentationResource;
+import org.simantics.document.server.DocumentServerUtils;
+import org.simantics.document.server.JSONObject;
+import org.simantics.layer0.Layer0;
+import org.simantics.structural.stubs.StructuralResource2;
+
+/**
+ * @author Antti Villberg
+ * @since 1.30.0
+ */
+public class DefaultFields extends VariableRead<JSONObject> {
+
+ public DefaultFields(Variable variable) {
+ super(variable);
+ }
+
+ @Override
+ public JSONObject perform(ReadGraph graph) throws DatabaseException {
+
+ Layer0 L0 = Layer0.getInstance(graph);
+ StructuralResource2.getInstance(graph);
+ DocumentationResource DOC = DocumentationResource.getInstance(graph);
+
+ String id = DocumentServerUtils.getId(graph, variable);
+
+ Binding jsonBinding = graph.getService(Databoard.class).getBindingUnchecked(JSONObject.class);
+ JSONObject object = new JSONObject(jsonBinding, id);
+
+ Resource type = variable.getType(graph);
+
+ Variable parentConnectionPoint = DocumentServerUtils.getParentConnectionPoint(graph, variable);
+ while (parentConnectionPoint != null) {
+ Variable par = parentConnectionPoint.getParent(graph);
+ if(!DOC.Components_DummyContainer.equals(par.getType(graph))) break;
+ parentConnectionPoint = DocumentServerUtils.getParentConnectionPoint(graph, par);
+ }
+
+ if(parentConnectionPoint != null) {
+ String parent = DocumentServerUtils.getId(graph, parentConnectionPoint.getParent(graph));
+ Resource cpPredicate = parentConnectionPoint.getPossiblePredicateResource(graph);
+ String i = null;
+ if (DOC.Relations_partN.equals(cpPredicate)) {
+ i = DocumentServerUtils.findManualOrdinal(graph, variable);
+ } else {
+ i = graph.getPossibleRelatedValue(cpPredicate, DOC.Document_ChildRelation_ordinal, Bindings.STRING);
+ }
+ if (i == null) {
+ i = "0";
+ }
+
+ object.addJSONField("parent", parent);
+ object.addJSONField("parentOrd", i);
+ } else {
+ if(DOC.Components_Root.equals(type) || graph.isInheritedFrom(type, DOC.Components_Root)) {
+ object.addJSONField("parent", "root");
+ object.addJSONField("parentOrd", "0");
+ } if(!graph.isInheritedFrom(type, DOC.Components_ParentlessComponent)) {
+ object.addJSONField("parent", "");
+ object.addJSONField("parentOrd", "0");
+ }
+ }
+
+ object.addJSONField("id", id);
+ object.addJSONField("type", graph.<String>getRelatedValue(type, L0.HasName, Bindings.STRING));
+ return object;
+
+ }
+
+}
\ No newline at end of file
+++ /dev/null
-package org.simantics.document.server.request;
-
-import gnu.trove.map.hash.THashMap;
-
-import java.util.Map;
-
-import org.simantics.db.ReadGraph;
-import org.simantics.document.base.ontology.DocumentationResource;
-import org.simantics.structural2.scl.ComponentTypeProperty;
-
-public class DocumentContext /*extends ExpressionContext*/ {
-/*
- private static Map<String,ComponentTypeProperty> get(ReadGraph graph) {
- Map<String,ComponentTypeProperty> properties = new THashMap<String,ComponentTypeProperty>();
- properties .put("input", new ComponentTypeProperty(DocumentationResource.getInstance(graph).Properties_input, ActualCompileRequest.VARIABLE));
- properties .put("self", new ComponentTypeProperty(DocumentationResource.getInstance(graph).Properties_self, ActualCompileRequest.VARIABLE));
- properties .put("model", new ComponentTypeProperty(DocumentationResource.getInstance(graph).Properties_model, ActualCompileRequest.VARIABLE));
- properties .put("experiment", new ComponentTypeProperty(DocumentationResource.getInstance(graph).Properties_experiment, ActualCompileRequest.VARIABLE));
- properties .put("graph", new ComponentTypeProperty(DocumentationResource.getInstance(graph).Properties_graph, ActualCompileRequest.READ_GRAPH_INTERNAL));
- return properties;
- }
-
- public DocumentContext(ReadGraph graph) {
- super(get(graph));
- }
-*/
-}
\ No newline at end of file
public class DocumentRequest extends VariableRead<List<JSONObject>> {
public static boolean PROFILE = false;
+ // Thresholds in microseconds
+ public static int PROFILE_THRESHOLD_NODEREQUEST = 2000;
+ public static int PROFILE_THRESHOLD_VALUEREQUEST = 500;
public DocumentRequest(Variable var) {
super(var);
if(PROFILE) {
long dura = System.nanoTime()-s;
- System.err.println("DocumentRequest " + System.identityHashCode(this) + " " + variable.getURI(graph) + " in " + 1e-6*dura + "ms.");
+ System.err.println("DocumentRequest " + System.identityHashCode(this) + " in " + 1e-6*dura + "ms. " + variable.getURI(graph));
}
return result;
import org.simantics.db.layer0.variable.Variables;
import org.simantics.db.request.Read;
import org.simantics.document.server.handler.AbstractEventHandler;
-import org.simantics.document.server.io.CommandContext;
import org.simantics.structural.stubs.StructuralResource2;
public class HandleEventRequest implements Read<AbstractEventHandler> {
package org.simantics.document.server.request;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.request.VariableRead;
import org.simantics.db.layer0.variable.Variable;
+import org.simantics.document.server.DocumentServerUtils.AttributesRequest;
import org.simantics.document.server.JSONObject;
+import org.simantics.utils.datastructures.Pair;
public class NodeRequest extends VariableRead<JSONObject> {
-
- public static String ERRORS = "Errors";
+
+ public static final String ERRORS = "Errors";
public NodeRequest(Variable node) {
super(node);
@SuppressWarnings("unchecked")
@Override
public JSONObject perform(ReadGraph graph) throws DatabaseException {
-
+
long s = System.nanoTime();
- JSONObject staticContent = graph.syncRequest(new NodeRequestStatic(variable));
+ Pair<JSONObject, Collection<Variable>> attribs = graph.syncRequest(new AttributesRequest(variable));
+
+ JSONObject staticContent = attribs.first;
+ if(attribs.second.isEmpty()) {
+
+ if(DocumentRequest.PROFILE) {
+ long dura = System.nanoTime()-s;
+ if(dura > DocumentRequest.PROFILE_THRESHOLD_NODEREQUEST * 1e3) {
+ System.err.println("NodeRequest " + System.identityHashCode(this) + " in " + 1e-6*dura + "ms. " + variable.getURI(graph));
+ }
+ }
+
+ return staticContent;
+ }
+
Map<String,Object> dynamicContent = graph.syncRequest(new NodeRequestDynamic(variable));
-
if(dynamicContent.isEmpty()) {
return staticContent;
}
-
+
JSONObject result = staticContent.clone();
result.add(dynamicContent);
if(dynamicContent.containsKey(ERRORS) || staticContent.getJSONField(ERRORS) != null) {
- ArrayList<String> errorList = new ArrayList<String>();
-
+ ArrayList<String> errorList = new ArrayList<>();
+
if(dynamicContent.containsKey(ERRORS))
errorList.addAll((List<String>)dynamicContent.get(ERRORS));
-
+
if(staticContent.getJSONField(ERRORS) != null)
errorList.addAll((List<String>)staticContent.getJSONField(ERRORS));
-
+
result.addJSONField(ERRORS, errorList);
}
-
+
if(DocumentRequest.PROFILE) {
- long dura = System.nanoTime()-s;
- System.err.println("NodeRequest " + System.identityHashCode(this) + " " + variable.getURI(graph) + " in " + 1e-6*dura + "ms." + result);
+ long dura = System.nanoTime()-s;
+ if(dura > DocumentRequest.PROFILE_THRESHOLD_NODEREQUEST * 1e3) {
+ System.err.println("NodeRequest " + System.identityHashCode(this) + " in " + 1e-6*dura + "ms. " + variable.getURI(graph));
+ }
}
- return result;
+ return result;
- }
+ }
}
\ No newline at end of file
+++ /dev/null
-package org.simantics.document.server.request;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import org.simantics.databoard.Bindings;
-import org.simantics.databoard.Databoard;
-import org.simantics.databoard.binding.Binding;
-import org.simantics.db.ReadGraph;
-import org.simantics.db.Resource;
-import org.simantics.db.exception.DatabaseException;
-import org.simantics.db.layer0.request.VariableRead;
-import org.simantics.db.layer0.variable.Variable;
-import org.simantics.document.base.ontology.DocumentationResource;
-import org.simantics.document.server.DocumentServerUtils;
-import org.simantics.document.server.JSONObject;
-import org.simantics.layer0.Layer0;
-import org.simantics.structural.stubs.StructuralResource2;
-
-class NodeRequestStatic extends VariableRead<JSONObject> {
-
- public NodeRequestStatic(Variable node) {
- super(node);
- }
-
- public static class Headers extends VariableRead<JSONObject> {
-
- public Headers(Variable variable) {
- super(variable);
- }
-
- @Override
- public JSONObject perform(ReadGraph graph) throws DatabaseException {
-
- Layer0 L0 = Layer0.getInstance(graph);
- StructuralResource2.getInstance(graph);
- DocumentationResource DOC = DocumentationResource.getInstance(graph);
-
- String id = DocumentServerUtils.getId(graph, variable);
-
- Binding jsonBinding = graph.getService(Databoard.class).getBindingUnchecked(JSONObject.class);
- JSONObject object = new JSONObject(jsonBinding, id);
-
- Resource type = variable.getType(graph);
-
- Variable parentConnectionPoint = DocumentServerUtils.getParentConnectionPoint(graph, variable);
- while (parentConnectionPoint != null) {
- Variable par = parentConnectionPoint.getParent(graph);
- if(!DOC.Components_DummyContainer.equals(par.getType(graph))) break;
- parentConnectionPoint = DocumentServerUtils.getParentConnectionPoint(graph, par);
- }
-
- if(parentConnectionPoint != null) {
- String parent = DocumentServerUtils.getId(graph, parentConnectionPoint.getParent(graph));
- Resource cpPredicate = parentConnectionPoint.getPossiblePredicateResource(graph);
- String i = null;
- if (DOC.Relations_partN.equals(cpPredicate)) {
- i = DocumentServerUtils.findManualOrdinal(graph, variable);
- } else {
- i = graph.getPossibleRelatedValue(cpPredicate, DOC.Document_ChildRelation_ordinal, Bindings.STRING);
- }
- if (i == null) {
- i = "0";
- }
-
- object.addJSONField("parent", parent);
- object.addJSONField("parentOrd", i);
- } else {
- if(DOC.Components_Root.equals(type) || graph.isInheritedFrom(type, DOC.Components_Root)) {
- object.addJSONField("parent", "root");
- object.addJSONField("parentOrd", "0");
- } if(!graph.isInheritedFrom(type, DOC.Components_ParentlessComponent)) {
- object.addJSONField("parent", "");
- object.addJSONField("parentOrd", "0");
- }
- }
-
- object.addJSONField("id", id);
- object.addJSONField("type", graph.<String>getRelatedValue(type, L0.HasName, Bindings.STRING));
- return object;
-
- }
-
- }
-
- @Override
- public JSONObject perform(ReadGraph graph) throws DatabaseException {
-
- long s = System.nanoTime();
-
- JSONObject base = graph.syncRequest(new Headers(variable));
- JSONObject object = base.clone();
-
- DocumentationResource DOC = DocumentationResource.getInstance(graph);
-
- for(Variable attrib : DocumentServerUtils.getStaticAttributes(graph, DOC, variable)) {
- String name = attrib.getName(graph);
- try {
- Object value = DocumentServerUtils.getValue(graph, attrib);
- object.addJSONField(name, value);
- } catch (Throwable t) {
- List<String> errorList = object.getJSONField(NodeRequest.ERRORS);
- if(errorList == null)
- errorList = new ArrayList<String>();
-
- String errorMessage = NodeRequestUtils.formatErrorMessage(name, t);
-
- errorList.add(errorMessage);
- object.addJSONField(NodeRequest.ERRORS, errorList);
- }
-
- }
-
- if(DocumentRequest.PROFILE) {
- long dura = System.nanoTime()-s;
- System.err.println("NodeRequestStatic " + System.identityHashCode(this) + " " + variable.getURI(graph) + " in " + 1e-6*dura + "ms." + object);
- }
-
- return object;
-
- }
-
-}
\ No newline at end of file
@Override
public Set<Variable> perform(ReadGraph graph) throws DatabaseException {
-
+
long s = System.nanoTime();
StructuralResource2.getInstance(graph);
if(variable == null)
return Collections.emptySet();
-
+
Set<Variable> nodes = new THashSet<Variable>();
Collection<Variable> children = graph.syncRequest(new VariableChildren(variable));
for(Variable child : children) {
if(DocumentRequest.PROFILE) {
long dura = System.nanoTime()-s;
- System.err.println("NodesRequest " + System.identityHashCode(this) + " " + variable.getURI(graph) + " in " + 1e-6*dura + "ms.");
+ System.err.println("NodesRequest " + System.identityHashCode(this) + " in " + 1e-6*dura + "ms. " + variable.getURI(graph));
}
return nodes;
@Override
public Set<Variable> perform(ReadGraph graph) throws DatabaseException {
- long s = System.nanoTime();
-
DocumentationResource DOC = DocumentationResource.getInstance(graph);
Resource type = variable.getPossibleType(graph);
Set<Variable> nodes = graph.syncRequest(new NodesRequest2(child));
result.addAll(nodes);
}
-
- if(DocumentRequest.PROFILE) {
- long dura = System.nanoTime()-s;
- System.err.println("NodesRequest2 " + System.identityHashCode(this) + " " + variable.getURI(graph) + " in " + 1e-6*dura + "ms.");
- }
return result;
}
package org.simantics.document.server.request;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.simantics.db.layer0.scl.AbstractExpressionCompilationRequest;
import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;
import org.simantics.db.layer0.variable.Variable;
-import org.simantics.document.server.Functions;
-import org.simantics.document.server.bean.DataDefinition;
import org.simantics.document.server.request.ServerSCLHandlerValueRequest.CompilationContext;
import org.simantics.layer0.Layer0;
-import org.simantics.scl.compiler.constants.StringConstant;
import org.simantics.scl.compiler.elaboration.expressions.EApply;
import org.simantics.scl.compiler.elaboration.expressions.EConstant;
-import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
-import org.simantics.scl.compiler.elaboration.expressions.EVar;
import org.simantics.scl.compiler.elaboration.expressions.EVariable;
import org.simantics.scl.compiler.elaboration.expressions.Expression;
import org.simantics.scl.compiler.elaboration.modules.SCLValue;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.layer0.scl.AbstractExpressionCompilationContext;
import org.simantics.db.layer0.scl.AbstractExpressionCompilationRequest;
-import org.simantics.db.layer0.util.RuntimeEnvironmentRequest;
import org.simantics.db.layer0.util.RuntimeEnvironmentRequest2;
import org.simantics.db.layer0.variable.Variable;
import org.simantics.document.server.request.ServerSCLValueRequest.CompilationContext;
MOD.SCLChildRule <T VP.ChildRule
>-- MOD.SCLChildRule.getChildren ==> "Resource -> <ReadGraph> [Resource]" <R L0.HasProperty : L0.FunctionalRelation
-MOD.SCLLabelRule <T VP.ChildRule
+MOD.SCLLabelRule <T VP.VisualsRule
>-- MOD.SCLLabelRule.getLabels ==> "Resource -> <ReadGraph> [String]" <R L0.HasProperty : L0.FunctionalRelation
MOD.SCLAction <T ACT.Action
L0.SCLValue.expression %expression
L0.HasValueType "Resource -> <ReadGraph> [Resource]"
+MOD.sclLabelRule : L0.Template
+ @template %action %expression
+ %action : MOD.SCLLabelRule
+ MOD.SCLLabelRule.getLabels _ : MOD.SCLValue
+ L0.SCLValue.expression %expression
+ L0.HasValueType "Resource -> <ReadGraph> [String]"
+
MOD.sclAction : L0.Template
@template %action %expression
%action : MOD.SCLAction
Code Review / simantics / platform.git / commitdiff