X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.district.network.ui%2Fsrc%2Forg%2Fsimantics%2Fdistrict%2Fnetwork%2Fui%2Ffunction%2FFunctions.java;h=627561a12ca04dba26d84676c22e6eaead598405;hb=4d9327aa40c5114f981741752305b7773122b580;hp=4fc40dbb109253fb5a2a2bf01a9eea0624dc6013;hpb=1bc60c2213f9b3fc7b4d935ba9afda2b767290e5;p=simantics%2Fdistrict.git diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java index 4fc40dbb..627561a1 100644 --- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java +++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/function/Functions.java @@ -1,9 +1,14 @@ package org.simantics.district.network.ui.function; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; import java.util.Collections; import java.util.HashMap; +import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.stream.Collectors; import org.eclipse.jface.dialogs.Dialog; @@ -38,18 +43,27 @@ import org.simantics.db.common.request.WriteRequest; import org.simantics.db.exception.DatabaseException; import org.simantics.db.exception.RuntimeDatabaseException; import org.simantics.db.exception.ServiceException; +import org.simantics.db.layer0.QueryIndexUtils; +import org.simantics.db.layer0.util.Layer0Utils; import org.simantics.db.layer0.variable.Variable; +import org.simantics.db.layer0.variable.Variables; import org.simantics.db.layer0.variable.Variables.Role; import org.simantics.db.procedure.Procedure; -import org.simantics.diagram.stubs.DiagramResource; import org.simantics.district.network.ontology.DistrictNetworkResource; import org.simantics.layer0.Layer0; import org.simantics.modeling.ModelingResources; -import org.simantics.modeling.ModelingUtils; import org.simantics.modeling.adapters.NewCompositeActionFactory; import org.simantics.modeling.typicals.TypicalUtil; +import org.simantics.operation.Layer0X; +import org.simantics.scl.compiler.commands.CommandSession; +import org.simantics.scl.compiler.commands.CommandSessionImportEntry; +import org.simantics.scl.compiler.errors.CompilationError; +import org.simantics.scl.osgi.SCLOsgi; import org.simantics.scl.reflection.annotations.SCLValue; -import org.simantics.structural.stubs.StructuralResource2; +import org.simantics.scl.runtime.SCLContext; +import org.simantics.scl.runtime.function.Function1; +import org.simantics.scl.runtime.function.FunctionImpl1; +import org.simantics.scl.runtime.reporting.SCLReportingHandler; import org.simantics.ui.workbench.action.DefaultActions; import org.simantics.utils.ui.SWTUtils; import org.slf4j.Logger; @@ -95,31 +109,33 @@ public class Functions { return baseMappingModifier(graph, element, DistrictNetworkResource.getInstance(graph).HasMapping, mappingType, context); } - public static Map getVertexMappings(ReadGraph graph, Resource resource) throws DatabaseException { - Map second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_VertexMapping); + public static Map getVertexMappings(ReadGraph graph, Resource indexRoot) throws DatabaseException { + Map second = getNetworkMappingsByType(graph, indexRoot, DistrictNetworkResource.getInstance(graph).Mapping_VertexMapping); return second; } - public static Map getEdgeMappings(ReadGraph graph, Resource resource) throws DatabaseException { - Map second = getNetworkMappingsByType(graph, resource , DistrictNetworkResource.getInstance(graph).Mapping_EdgeMapping); + public static Map getEdgeMappings(ReadGraph graph, Resource indexRoot) throws DatabaseException { + Map second = getNetworkMappingsByType(graph, indexRoot, DistrictNetworkResource.getInstance(graph).Mapping_EdgeMapping); return second; } public static Map getCRSs(ReadGraph graph, Resource resource) throws DatabaseException { - Map result = getNetworkMappingsByType(graph, resource, DistrictNetworkResource.getInstance(graph).SpatialRefSystem); + Map result = getNetworkMappingsByType(graph, graph.sync(new IndexRoot(resource)), DistrictNetworkResource.getInstance(graph).SpatialRefSystem); return result; } - public static Map getNetworkMappingsByType(ReadGraph graph, Resource element, Resource mappingType) throws DatabaseException { - Resource indexRoot = graph.sync(new IndexRoot(element)); - List mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType); + public static Map getNetworkMappingsByType(ReadGraph graph, Resource indexRoot, Resource mappingType) throws DatabaseException { + List mappings = QueryIndexUtils.searchByType(graph, indexRoot, mappingType); Map result = new HashMap<>(mappings.size()); Layer0 L0 = Layer0.getInstance(graph); mappings.forEach(mapping -> { try { String name = graph.getRelatedValue2(mapping, L0.HasName); - result.put(name, mapping); + Resource existing = result.put(name, mapping); + if (existing != null) { + LOGGER.warn("Duplicate mapping name! {} {} and existing is {}", name, mapping, existing); + } } catch (DatabaseException e) { e.printStackTrace(); } @@ -129,7 +145,7 @@ public class Functions { private static Object baseMappingModifier(ReadGraph graph, Resource element, Resource property, Resource mappingType, Variable context) throws DatabaseException { Resource indexRoot = graph.sync(new IndexRoot(element)); - List mappings = ModelingUtils.searchByType(graph, indexRoot, mappingType); + List mappings = QueryIndexUtils.searchByType(graph, indexRoot, mappingType); Enumeration enums = Enumeration .make(mappings.stream().map(m -> createEnumeratedValue(graph, m)).collect(Collectors.toList())); @@ -174,8 +190,11 @@ public class Functions { @SCLValue(type = "ReadGraph -> Resource -> a -> b") public static Object convertToValue(ReadGraph graph, Resource resource, Object context) throws DatabaseException { - return graph.getRelatedValue2(resource, Layer0.getInstance(graph).HasName, Bindings.STRING); -// return null; + Layer0 L0 = Layer0.getInstance(graph); + String label = graph.getPossibleRelatedValue2(resource, L0.HasLabel, Bindings.STRING); + if (label == null) + label = graph.getRelatedValue(resource, L0.HasName, Bindings.STRING); + return label; } @@ -207,7 +226,6 @@ public class Functions { private Map edgeMappings = new HashMap<>(); private Map composites = new HashMap<>(); private Map crss = new HashMap<>(); - private Map> components = new HashMap<>(); private Resource defaultVertexMapping; private Resource defaultEdgeMapping; @@ -243,15 +261,12 @@ public class Functions { @Override public void run(ReadGraph graph) throws DatabaseException { - - vertexMappings = getVertexMappings(graph, configuration); - edgeMappings = getEdgeMappings(graph, configuration); + Resource indexRoot = graph.sync(new IndexRoot(configuration)); + vertexMappings = getVertexMappings(graph, indexRoot); + edgeMappings = getEdgeMappings(graph, indexRoot); composites = getComposites(graph, configuration); - if (composites.size() > 0) { - components = getComponents(graph, composites.get(0)); - } - + crss = getCRSs(graph, configuration); composite.getDisplay().asyncExec(() -> { @@ -276,16 +291,7 @@ public class Functions { return composite; } - protected Map> getComponents(ReadGraph graph, Resource resource) { - // TODO Auto-generated method stub - return null; - } - protected Map getComposites(ReadGraph graph, Resource element) throws DatabaseException { - - Resource indexRoot = graph.sync(new IndexRoot(element)); - List diagrams = ModelingUtils.searchByType(graph, indexRoot, DiagramResource.getInstance(graph).Diagram); - List nonDistrictComposites = composites.values().stream().filter(comp -> { try { return !graph.isInstanceOf(comp, DistrictNetworkResource.getInstance(graph).Composite); @@ -432,6 +438,10 @@ public class Functions { graph.claim(diagram, DN.EdgeDefaultMapping, dialog.getDefaultEdgeMapping()); graph.claim(diagram, DN.VertexDefaultMapping, dialog.getDefaultVertexMapping()); graph.claim(diagram, DN.HasSpatialRefSystem, dialog.getCRS()); + + // Generated name prefix from composite name + String compositeName = graph.getRelatedValue2(composite, Layer0.getInstance(graph).HasName, Bindings.STRING); + graph.claimLiteral(diagram, Layer0X.getInstance(graph).HasGeneratedNamePrefix, "N" + compositeName.substring(compositeName.length() - 1, compositeName.length())); } }); DefaultActions.asyncPerformDefaultAction(Simantics.getSession(), composite, false, false, true); @@ -446,7 +456,188 @@ public class Functions { }); } - public static void getDistrictDiagrams(ReadGraph graph) { - + public static Collection getDistrictDiagrams(ReadGraph graph) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + Collection indexRoots = graph.sync(new ObjectsWithType(Simantics.getProjectResource(), L0.ConsistsOf, L0.IndexRoot)); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + Set results = new HashSet<>(); + for (Resource indexRoot : indexRoots) { + Collection diagrams = QueryIndexUtils.searchByType(graph, indexRoot, DN.Diagram); + results.addAll(diagrams); + } + return results; + } + + private static List listInstanceNames(ReadGraph graph, Variable context, Resource type) throws DatabaseException { + Resource indexRoot = Variables.getIndexRoot(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + List properties = QueryIndexUtils.searchByType(graph, indexRoot, DN.Vertex_ScaleProperty); + return properties.stream() + .map(m -> createEnumeratedValue(graph, m)) + .map(EnumeratedValue::getName) + .collect(Collectors.toList()); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object edgeThicknessPropertyEnumerationValues(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return listInstanceNames(graph, context, DN.Edge_ThicknessProperty); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object nodeScalePropertyEnumerationValues(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return listInstanceNames(graph, context, DN.Vertex_ScaleProperty); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object edgeThicknessPropertyModifier(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + Resource diagram = resolveElement(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return baseMappingModifier(graph, diagram, DN.Diagram_edgeThicknessProperty, DN.Edge_ThicknessProperty, context); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object nodeScalePropertyModifier(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + Resource diagram = resolveElement(graph, context); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + return baseMappingModifier(graph, diagram, DN.Diagram_nodeScaleProperty, DN.Vertex_ScaleProperty, context); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasDiameterValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Edge_HasDiameter, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasNominalMassFlowValue(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Edge_HasNominalMassFlow, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasNominalSupplyPressure(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Vertex_HasSupplyPressure, 0); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 hasElevation(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return directPropertyValueFunction(DistrictNetworkResource.getInstance(graph).Vertex_HasElevation, 0); + } + + private static final Function1 ONE = new FunctionImpl1() { + private final Double ONE = 1.0; + @Override + public Double apply(Resource edge) { + return ONE; + } + @Override + public String toString() { + return "1"; + } + }; + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Function1 constantOne(ReadGraph graph, Resource resource, Variable context) throws DatabaseException { + return ONE; + } + + private static Function1 directPropertyValueFunction(Resource property, double defaultValue) throws DatabaseException { + Double def = defaultValue; + return new FunctionImpl1() { + @Override + public Double apply(Resource edge) { + ReadGraph graph = (ReadGraph) SCLContext.getCurrent().get("graph"); + try { + Double d = graph.getPossibleRelatedValue(edge, property, Bindings.DOUBLE); + return d != null ? d : def; + } catch (DatabaseException e) { + LOGGER.error("Failed to evaluate property value", e); + return def; + } + } + }; + } + + private static class RangeValidator implements Function1 { + private double min; + private double max; + public RangeValidator(double min, double max) { + this.min = min; + this.max = max; + } + @Override + public String apply(String s) { + try { + double d = Double.parseDouble(s); + if (d < min) + return "Value must be greater than or equal to " + min; + if (d > max) + return "Value must be less than or equal to " + max; + return null; + } catch (NumberFormatException e) { + return "Specified value is not a number"; + } + } + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object hueValidator(ReadGraph graph, Resource r, Variable context) throws DatabaseException { + return new RangeValidator(0, 360); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object saturationValidator(ReadGraph graph, Resource r, Variable context) throws DatabaseException { + return new RangeValidator(0, 100); + } + + @SCLValue(type = "ReadGraph -> Resource -> Variable -> b") + public static Object brightnessValidator(ReadGraph graph, Resource r, Variable context) throws DatabaseException { + String importEntry = null; + Resource root = Variables.getPossibleIndexRoot(graph, context); + if (root != null) { + Resource sclmain = Layer0Utils.getPossibleChild(graph, root, "SCLMain"); + if (sclmain != null) { + importEntry = graph.getPossibleURI(sclmain); + } + } + SCLContext ctx = SCLContext.getCurrent(); + Object oldGraph = ctx.put("graph", graph); + try { + return new BrightnessExpressionValidator( + importEntry != null + ? Arrays.asList(importEntry) + : Collections.emptyList()); + } finally { + ctx.put("graph", oldGraph); + } } + + private static class BrightnessExpressionValidator implements Function1 { + private CommandSession session; + + public BrightnessExpressionValidator(List importEntries) { + this.session = new CommandSession(SCLOsgi.MODULE_REPOSITORY, SCLReportingHandler.DEFAULT); + this.session.setImportEntries(imports(importEntries)); + } + + private ArrayList imports(List entries) { + ArrayList result = new ArrayList<>(); + entries.stream().map(CommandSessionImportEntry::new).forEach(result::add); + if (entries.isEmpty()) + result.add(new CommandSessionImportEntry("Simantics/District/SCLMain")); + return result; + } + + @Override + public String apply(String s) { + s = s.trim(); + if (!s.startsWith("=")) + return "Expression expected, must start with '='"; + CompilationError[] errors = session.validate(s.substring(1)); + if(errors.length == 0) + return null; + return errors[0].description; + } + } + }